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
182
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CHROME_BROWSER_DOWNLOAD_BUBBLE_DOWNLOAD_BUBBLE_UI_CONTROLLER_H_
#define CHROME_BROWSER_DOWNLOAD_BUBBLE_DOWNLOAD_BUBBLE_UI_CONTROLLER_H_
#include <optional>
#include <set>
#include "base/memory/raw_ptr.h"
#include "base/scoped_observation.h"
#include "chrome/browser/download/bubble/download_bubble_update_service.h"
#include "chrome/browser/download/bubble/download_display_controller.h"
#include "chrome/browser/download/download_warning_desktop_hats_utils.h"
#include "chrome/browser/download/offline_item_model.h"
#include "chrome/browser/metrics/browser_activity_watcher.h"
#include "components/download/content/public/all_download_item_notifier.h"
#include "components/offline_items_collection/core/offline_content_aggregator.h"
#include "components/offline_items_collection/core/offline_content_provider.h"
class Profile;
namespace offline_items_collection {
struct ContentId;
}
// This handles the window-level logic for controlling the download bubble.
// There is one instance of this class per browser window, and it is owned by
// the download toolbar button.
class DownloadBubbleUIController {
public:
// Get a valid controller for the given `download`. In the case of web apps,
// this will always be the web app window's controller. For regular downloads,
// this could be the controller for the most recently active window associated
// with this profile.
static DownloadBubbleUIController* GetForDownload(
download::DownloadItem* download);
explicit DownloadBubbleUIController(Browser* browser);
// Used to inject a custom DownloadBubbleUpdateService for testing. Prefer
// the constructor above which uses that of the profile.
DownloadBubbleUIController(Browser* browser,
DownloadBubbleUpdateService* update_service);
DownloadBubbleUIController(const DownloadBubbleUIController&) = delete;
DownloadBubbleUIController& operator=(const DownloadBubbleUIController&) =
delete;
virtual ~DownloadBubbleUIController();
// These methods are called to notify the UI of new events.
// |may_show_animation| is whether the window this controller belongs to may
// show the animation. (Whether the animation is actually shown may depend on
// the download and the device's graphics capabilities.) We don't show an
// animation for offline items. Notifications for created/added download items
// generally come from the DownloadUIController(Delegate) (except for crx
// downloads, which come via the DownloadBubbleUpdateService), and the rest
// are called from DownloadBubbleUpdateService.
void OnDownloadItemAdded(download::DownloadItem* item,
bool may_show_animation);
void OnDownloadItemUpdated(download::DownloadItem* item);
void OnDownloadItemRemoved(download::DownloadItem* item);
void OnOfflineItemsAdded(
const OfflineContentProvider::OfflineItemList& items);
void OnOfflineItemUpdated(const OfflineItem& item);
void OnOfflineItemRemoved(const ContentId& id);
// Get the entries for the main view of the Download Bubble. The main view
// contains all the recent downloads (finished within the last 24 hours).
// Virtual for testing.
virtual std::vector<DownloadUIModel::DownloadUIModelPtr> GetMainView();
// Get the entries for the partial view of the Download Bubble. The partial
// view contains in-progress and uninteracted downloads, meant to capture the
// user's recent tasks. This can only be opened by the browser in the event of
// new downloads, and user action only creates a main view.
// Virtual for testing.
virtual std::vector<DownloadUIModel::DownloadUIModelPtr> GetPartialView();
// Process button press on the bubble.
// May launch a HaTS survey if the action applies to a download warning.
// TODO(chlily): `is_main_view` should be named `is_primary_view`. It
// distinguishes the primary page from the (security) subpage, not the main vs
// partial flavors of the primary view.
void ProcessDownloadButtonPress(base::WeakPtr<DownloadUIModel> model,
DownloadCommands::Command command,
bool is_main_view);
// Notify when a download toolbar button (in any window) is pressed.
void HandleButtonPressed();
// Schedules the ephemeral warning download to be hidden from the bubble, and
// subsequently canceled. It will only be canceled if it continues to be an
// ephemeral warning that hasn't been acted on when the scheduled time
// arrives.
void ScheduleCancelForEphemeralWarning(const std::string& guid);
// Force the controller to hide the download UI entirely, including the bubble
// and the toolbar icon. This function should only be called if the event is
// triggered outside of normal download events that are not listened by
// observers.
void HideDownloadUi();
// Records that a dangerous download was shown to the user. This only
// records the fact that an interaction occurred, and should not be
// used quantitatively to count the number of such interactions.
void RecordDangerousDownloadShownToUser(download::DownloadItem* download);
// Returns the DownloadDisplayController. Should always return a valid
// controller.
DownloadDisplayController* GetDownloadDisplayController() {
return display_controller_;
}
void SetDownloadDisplayController(DownloadDisplayController* controller) {
display_controller_ = controller;
}
DownloadBubbleUpdateService* update_service() { return update_service_; }
// See comment on member below. This may not be correct/meaningful, do not
// rely on this for anything important. This is not meaningful if the partial
// view is not enabled.
bool last_primary_view_was_partial() const {
return last_primary_view_was_partial_;
}
base::WeakPtr<DownloadBubbleUIController> GetWeakPtr();
private:
friend class DownloadBubbleUIControllerTest;
friend class DownloadBubbleUIControllerIncognitoTest;
// Common method for getting main and partial views.
std::vector<DownloadUIModel::DownloadUIModelPtr> GetDownloadUIModels(
bool is_main_view);
// Kick off retrying an eligible interrupted download.
void RetryDownload(DownloadUIModel* model, DownloadCommands::Command command);
// Stamps the PSD for HaTS surveys with the extra info specific to the
// download bubble triggers.
void CompleteHatsPsd(DownloadWarningHatsProductSpecificData& psd);
// Callback for `browser_activity_observer_`.
void OnBrowserActivity();
raw_ptr<Browser, DanglingUntriaged> browser_;
raw_ptr<Profile, DanglingUntriaged> profile_;
raw_ptr<DownloadBubbleUpdateService, DanglingUntriaged> update_service_;
raw_ptr<OfflineItemModelManager, DanglingUntriaged> offline_manager_;
// DownloadDisplayController and DownloadBubbleUIController have the same
// lifetime. Both are owned, constructed together, and destructed together by
// DownloadToolbarButtonView. If one is valid, so is the other.
raw_ptr<DownloadDisplayController, AcrossTasksDanglingUntriaged>
display_controller_;
std::optional<base::Time> last_partial_view_shown_time_ = std::nullopt;
// Tracks whether the last time we provided models was for a partial view
// (true) or a main view (false). This is an approximation for whether the
// last incarnation of the download bubble that the user saw or interacted
// with was a partial or main view. (It's only an approximation because there
// are controllers for other browsers that are not accounted for here.) In
// most cases, this should be correct and meaningful if queried immediately
// after the user interacted with / clicked on the bubble. This value might
// be bogus if the download bubble is shown on multiple browsers at the same
// time, or if the primary view is bypassed altogether (e.g. by clicking on
// a desktop notification on ChromeOS to go to the security view directly).
bool last_primary_view_was_partial_ = false;
// Used for showing HaTS surveys when download warnings are delayed.
// Nullptr when the user is not eligible for download bubble warning ignored
// surveys.
std::unique_ptr<DelayedDownloadWarningHatsLauncher> delayed_hats_launcher_;
std::unique_ptr<BrowserActivityWatcher> browser_activity_watcher_;
base::WeakPtrFactory<DownloadBubbleUIController> weak_factory_{this};
};
#endif // CHROME_BROWSER_DOWNLOAD_BUBBLE_DOWNLOAD_BUBBLE_UI_CONTROLLER_H_
|
