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
|
// Copyright (c) 2011 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/memory/weak_ptr.h"
#include "base/time.h"
class DownloadItem;
class FilePath;
class TabContents;
class SavePackage;
namespace content {
// Browser's download manager: manages all downloads and destination view.
class DownloadManagerDelegate {
public:
virtual ~DownloadManagerDelegate() {}
// Lets the delegate know that the download manager is shutting down.
virtual void Shutdown() = 0;
// 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) = 0;
// Asks the user for the path for a download. The delegate calls
// DownloadManager::FileSelected or DownloadManager::FileSelectionCanceled to
// give the answer.
virtual void ChooseDownloadPath(TabContents* tab_contents,
const FilePath& suggested_path,
void* data) = 0;
// Allows the embedder to override the file path for the download while it's
// progress. Return false to leave the filename as item->full_path(), or
// return true and set |intermediate_path| with the intermediate path.
virtual bool OverrideIntermediatePath(DownloadItem* item,
FilePath* intermediate_path) = 0;
// Called when the download system wants to alert a TabContents that a
// download has started, but the TabConetnts has gone away. This lets an
// delegate return an alternative TabContents. The delegate can return NULL.
virtual TabContents* GetAlternativeTabContentsToNotifyForDownload() = 0;
// Tests if a file type should be opened automatically.
virtual bool ShouldOpenFileBasedOnExtension(const FilePath& path) = 0;
// 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
// DownloadManager::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) = 0;
// 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) = 0;
// Returns true if we need to generate a binary hash for downloads.
virtual bool GenerateFileHash() = 0;
// Informs the delegate that given download has finishd downloading.
virtual void OnResponseCompleted(DownloadItem* item) = 0;
// 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) = 0;
// 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) = 0;
// 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) = 0;
// Notifies the delegate that it should remove the download item from its
// persistent store.
virtual void RemoveItemFromPersistentStore(DownloadItem* item) = 0;
// Notifies the delegate to remove downloads from the given time range.
virtual void RemoveItemsFromPersistentStoreBetween(
const base::Time remove_begin,
const base::Time remove_end) = 0;
// Retrieve the directories to save html pages and downloads to.
virtual void GetSaveDir(TabContents* tab_contents,
FilePath* website_save_dir,
FilePath* download_save_dir) = 0;
// Asks the user for the path to save a page. The delegate calls
// SavePackage::OnPathPicked to give the answer.
virtual void ChooseSavePath(const base::WeakPtr<SavePackage>& save_package,
const FilePath& suggested_path,
bool can_save_as_complete) = 0;
// Informs the delegate that the progress of downloads has changed.
virtual void DownloadProgressUpdated() = 0;
protected:
DownloadManagerDelegate() {}
DISALLOW_COPY_AND_ASSIGN(DownloadManagerDelegate);
};
} // namespace content
#endif // CONTENT_PUBLIC_BROWSER_DOWNLOAD_MANAGER_DELEGATE_H_
|
