[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 1 | // Copyright (c) 2013 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 | #include "chrome/browser/extensions/extension_message_bubble_controller.h" |
| 6 | |
Jinho Bang | b5216cec | 2018-01-17 19:43:11 | [diff] [blame] | 7 | #include <memory> |
Daniel Cheng | d78c025 | 2019-04-26 17:22:11 | [diff] [blame] | 8 | #include <utility> |
Jinho Bang | b5216cec | 2018-01-17 19:43:11 | [diff] [blame] | 9 | |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 10 | #include "base/bind.h" |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 11 | #include "base/lazy_instance.h" |
asvitkine | aa06031 | 2016-09-01 22:44:13 | [diff] [blame] | 12 | #include "base/metrics/histogram_macros.h" |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 13 | #include "base/strings/string_number_conversions.h" |
| 14 | #include "base/strings/string_util.h" |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 15 | #include "base/strings/utf_string_conversions.h" |
[email protected] | f845448465 | 2014-02-27 04:20:42 | [diff] [blame] | 16 | #include "chrome/browser/profiles/profile.h" |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 17 | #include "chrome/browser/ui/browser.h" |
rdevlin.cronin | 8937030 | 2016-04-19 14:24:40 | [diff] [blame] | 18 | #include "chrome/browser/ui/browser_list.h" |
apacible | f9cfc4d | 2015-08-18 05:14:14 | [diff] [blame] | 19 | #include "chrome/browser/ui/toolbar/toolbar_actions_model.h" |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 20 | #include "chrome/common/url_constants.h" |
thestig | 4a2e88e | 2016-08-27 23:23:51 | [diff] [blame] | 21 | #include "components/strings/grit/components_strings.h" |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 22 | #include "extensions/browser/extension_prefs.h" |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 23 | #include "extensions/browser/extension_system.h" |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 24 | #include "ui/base/l10n/l10n_util.h" |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 25 | |
| 26 | namespace extensions { |
| 27 | |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 28 | namespace { |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 29 | |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 30 | // How many extensions to show in the bubble (max). |
| 31 | const int kMaxExtensionsToShow = 7; |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 32 | |
| 33 | // Whether or not to ignore the learn more link navigation for testing. |
| 34 | bool g_should_ignore_learn_more_for_testing = false; |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 35 | |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 36 | } // namespace |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 37 | |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 38 | //////////////////////////////////////////////////////////////////////////////// |
[email protected] | 4f2f353d | 2014-01-14 11:21:09 | [diff] [blame] | 39 | // ExtensionMessageBubbleController::Delegate |
| 40 | |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 41 | ExtensionMessageBubbleController::Delegate::Delegate(Profile* profile) |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 42 | : profile_(profile), |
| 43 | service_(ExtensionSystem::Get(profile)->extension_service()), |
| 44 | registry_(ExtensionRegistry::Get(profile)) { |
[email protected] | 4f2f353d | 2014-01-14 11:21:09 | [diff] [blame] | 45 | } |
| 46 | |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 47 | ExtensionMessageBubbleController::Delegate::~Delegate() {} |
[email protected] | 4f2f353d | 2014-01-14 11:21:09 | [diff] [blame] | 48 | |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 49 | base::string16 ExtensionMessageBubbleController::Delegate::GetLearnMoreLabel() |
| 50 | const { |
| 51 | return l10n_util::GetStringUTF16(IDS_LEARN_MORE); |
| 52 | } |
| 53 | |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 54 | void ExtensionMessageBubbleController::Delegate::OnAction() {} |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 55 | |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 56 | bool ExtensionMessageBubbleController::Delegate::HasBubbleInfoBeenAcknowledged( |
| 57 | const std::string& extension_id) { |
| 58 | std::string pref_name = get_acknowledged_flag_pref_name(); |
| 59 | if (pref_name.empty()) |
| 60 | return false; |
| 61 | bool pref_state = false; |
| 62 | extensions::ExtensionPrefs* prefs = extensions::ExtensionPrefs::Get(profile_); |
| 63 | prefs->ReadPrefAsBoolean(extension_id, pref_name, &pref_state); |
| 64 | return pref_state; |
| 65 | } |
| 66 | |
| 67 | void ExtensionMessageBubbleController::Delegate::SetBubbleInfoBeenAcknowledged( |
| 68 | const std::string& extension_id, |
| 69 | bool value) { |
| 70 | std::string pref_name = get_acknowledged_flag_pref_name(); |
| 71 | if (pref_name.empty()) |
| 72 | return; |
| 73 | extensions::ExtensionPrefs* prefs = extensions::ExtensionPrefs::Get(profile_); |
vabr | fb687dc | 2017-03-22 11:40:57 | [diff] [blame] | 74 | prefs->UpdateExtensionPref( |
| 75 | extension_id, pref_name, |
Jinho Bang | b5216cec | 2018-01-17 19:43:11 | [diff] [blame] | 76 | value ? std::make_unique<base::Value>(value) : nullptr); |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 77 | } |
| 78 | |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 79 | std::string |
| 80 | ExtensionMessageBubbleController::Delegate::get_acknowledged_flag_pref_name() |
| 81 | const { |
| 82 | return acknowledged_pref_name_; |
| 83 | } |
| 84 | |
ki.stfu | f38f931 | 2015-09-27 14:44:37 | [diff] [blame] | 85 | void ExtensionMessageBubbleController::Delegate:: |
| 86 | set_acknowledged_flag_pref_name(const std::string& pref_name) { |
merkulova | 9be182e | 2014-10-07 14:57:50 | [diff] [blame] | 87 | acknowledged_pref_name_ = pref_name; |
| 88 | } |
| 89 | |
[email protected] | 4f2f353d | 2014-01-14 11:21:09 | [diff] [blame] | 90 | //////////////////////////////////////////////////////////////////////////////// |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 91 | // ExtensionMessageBubbleController |
| 92 | |
| 93 | ExtensionMessageBubbleController::ExtensionMessageBubbleController( |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 94 | Delegate* delegate, |
| 95 | Browser* browser) |
| 96 | : browser_(browser), |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 97 | model_(ToolbarActionsModel::Get(browser_->profile())), |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 98 | user_action_(ACTION_BOUNDARY), |
| 99 | delegate_(delegate), |
rdevlin.cronin | 9bd430a | 2015-05-08 18:06:18 | [diff] [blame] | 100 | initialized_(false), |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 101 | is_highlighting_(false), |
Evan Stade | 75872a6 | 2019-09-06 21:17:38 | [diff] [blame] | 102 | is_active_bubble_(false) { |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 103 | extension_registry_observer_.Add(ExtensionRegistry::Get(browser_->profile())); |
Evan Stade | 75872a6 | 2019-09-06 21:17:38 | [diff] [blame] | 104 | BrowserList::AddObserver(this); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | ExtensionMessageBubbleController::~ExtensionMessageBubbleController() { |
Evan Stade | 75872a6 | 2019-09-06 21:17:38 | [diff] [blame] | 108 | BrowserList::RemoveObserver(this); |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 109 | if (is_active_bubble_) |
| 110 | model_->set_has_active_bubble(false); |
| 111 | if (is_highlighting_) |
| 112 | model_->StopHighlighting(); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 113 | } |
| 114 | |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 115 | Profile* ExtensionMessageBubbleController::profile() { |
| 116 | return browser_->profile(); |
| 117 | } |
| 118 | |
rdevlin.cronin | cce78d0 | 2015-09-24 19:50:55 | [diff] [blame] | 119 | bool ExtensionMessageBubbleController::ShouldShow() { |
catmullings | 6e55772 | 2016-12-17 02:55:26 | [diff] [blame] | 120 | // In the case when there are multiple extensions in the list, we need to |
| 121 | // check if each extension entry is still installed, and, if not, remove it |
| 122 | // from the list. |
| 123 | UpdateExtensionIdList(); |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 124 | return !GetExtensionIdList().empty() && |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 125 | (!model_->has_active_bubble() || is_active_bubble_) && |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 126 | delegate_->ShouldShow(GetExtensionIdList()); |
rdevlin.cronin | cce78d0 | 2015-09-24 19:50:55 | [diff] [blame] | 127 | } |
| 128 | |
[email protected] | 4f58ac5 | 2013-12-17 12:00:42 | [diff] [blame] | 129 | std::vector<base::string16> |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 130 | ExtensionMessageBubbleController::GetExtensionList() { |
| 131 | ExtensionIdList* list = GetOrCreateExtensionList(); |
| 132 | if (list->empty()) |
[email protected] | 4f58ac5 | 2013-12-17 12:00:42 | [diff] [blame] | 133 | return std::vector<base::string16>(); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 134 | |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 135 | ExtensionRegistry* registry = ExtensionRegistry::Get(profile()); |
[email protected] | 4f58ac5 | 2013-12-17 12:00:42 | [diff] [blame] | 136 | std::vector<base::string16> return_value; |
rdevlin.cronin | cce78d0 | 2015-09-24 19:50:55 | [diff] [blame] | 137 | for (const std::string& id : *list) { |
[email protected] | f47f717 | 2014-03-19 19:27:10 | [diff] [blame] | 138 | const Extension* extension = |
rdevlin.cronin | cce78d0 | 2015-09-24 19:50:55 | [diff] [blame] | 139 | registry->GetExtensionById(id, ExtensionRegistry::EVERYTHING); |
catmullings | 6e55772 | 2016-12-17 02:55:26 | [diff] [blame] | 140 | return_value.push_back(base::UTF8ToUTF16(extension->name())); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 141 | } |
| 142 | return return_value; |
| 143 | } |
| 144 | |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 145 | base::string16 ExtensionMessageBubbleController::GetExtensionListForDisplay() { |
| 146 | if (!delegate_->ShouldShowExtensionList()) |
| 147 | return base::string16(); |
| 148 | |
| 149 | std::vector<base::string16> extension_list = GetExtensionList(); |
| 150 | if (extension_list.size() > kMaxExtensionsToShow) { |
| 151 | int old_size = extension_list.size(); |
| 152 | extension_list.erase(extension_list.begin() + kMaxExtensionsToShow, |
| 153 | extension_list.end()); |
Raul Tambre | fff51b75 | 2019-02-04 13:09:47 | [diff] [blame] | 154 | extension_list.push_back(delegate_->GetOverflowText( |
| 155 | base::NumberToString16(old_size - kMaxExtensionsToShow))); |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 156 | } |
| 157 | const base::char16 bullet_point = 0x2022; |
| 158 | base::string16 prefix = bullet_point + base::ASCIIToUTF16(" "); |
| 159 | for (base::string16& str : extension_list) |
| 160 | str.insert(0, prefix); |
brettw | d94a2214 | 2015-07-15 05:19:26 | [diff] [blame] | 161 | return base::JoinString(extension_list, base::ASCIIToUTF16("\n")); |
rdevlin.cronin | a28846d | 2015-04-30 23:12:19 | [diff] [blame] | 162 | } |
| 163 | |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 164 | const ExtensionIdList& ExtensionMessageBubbleController::GetExtensionIdList() { |
| 165 | return *GetOrCreateExtensionList(); |
| 166 | } |
| 167 | |
catmullings | 6e55772 | 2016-12-17 02:55:26 | [diff] [blame] | 168 | void ExtensionMessageBubbleController::UpdateExtensionIdList() { |
| 169 | ExtensionIdList* extension_ids = GetOrCreateExtensionList(); |
| 170 | ExtensionRegistry* registry = ExtensionRegistry::Get(profile()); |
| 171 | int include_mask = delegate_->ShouldLimitToEnabledExtensions() |
| 172 | ? ExtensionRegistry::ENABLED |
| 173 | : ExtensionRegistry::EVERYTHING; |
| 174 | for (auto iter = extension_ids->begin(); iter != extension_ids->end();) { |
| 175 | const Extension* extension = |
| 176 | registry->GetExtensionById(*iter, include_mask); |
| 177 | if (extension) |
| 178 | ++iter; |
| 179 | else |
| 180 | iter = extension_ids->erase(iter); |
| 181 | } |
| 182 | } |
| 183 | |
rdevlin.cronin | 690e44f | 2015-11-06 00:27:14 | [diff] [blame] | 184 | bool ExtensionMessageBubbleController::CloseOnDeactivate() { |
| 185 | return delegate_->ShouldCloseOnDeactivate(); |
| 186 | } |
[email protected] | 94b8a51a | 2014-03-26 20:57:55 | [diff] [blame] | 187 | |
rdevlin.cronin | 70fc605 | 2015-04-15 17:49:06 | [diff] [blame] | 188 | void ExtensionMessageBubbleController::HighlightExtensionsIfNecessary() { |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 189 | DCHECK(is_active_bubble_); |
| 190 | if (delegate_->ShouldHighlightExtensions() && !is_highlighting_) { |
| 191 | is_highlighting_ = true; |
rdevlin.cronin | 70fc605 | 2015-04-15 17:49:06 | [diff] [blame] | 192 | const ExtensionIdList& extension_ids = GetExtensionIdList(); |
| 193 | DCHECK(!extension_ids.empty()); |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 194 | model_->HighlightActions(extension_ids, |
| 195 | ToolbarActionsModel::HIGHLIGHT_WARNING); |
rdevlin.cronin | 70fc605 | 2015-04-15 17:49:06 | [diff] [blame] | 196 | } |
| 197 | } |
rdevlin.cronin | 86261efe | 2015-04-13 17:42:30 | [diff] [blame] | 198 | |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 199 | void ExtensionMessageBubbleController::OnShown( |
| 200 | const base::Closure& close_bubble_callback) { |
| 201 | close_bubble_callback_ = close_bubble_callback; |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 202 | DCHECK(is_active_bubble_); |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 203 | delegate_->OnShown(GetExtensionIdList()); |
| 204 | |
| 205 | if (!extension_registry_observer_.IsObserving( |
| 206 | ExtensionRegistry::Get(browser_->profile()))) { |
| 207 | extension_registry_observer_.Add( |
| 208 | ExtensionRegistry::Get(browser_->profile())); |
| 209 | } |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 210 | } |
| 211 | |
| 212 | void ExtensionMessageBubbleController::OnBubbleAction() { |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 213 | // In addition to closing the bubble, OnBubbleAction() may result in a removal |
| 214 | // or disabling of the extension. To prevent triggering OnExtensionUnloaded(), |
| 215 | // which will also try to close the bubble, the controller's extension |
| 216 | // registry observer is removed. Note, we do not remove the extension registry |
| 217 | // observer in the cases of OnBubbleDismiss() and OnLinkedClicked() since they |
| 218 | // do not result in extensions being unloaded. |
| 219 | extension_registry_observer_.RemoveAll(); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 220 | DCHECK_EQ(ACTION_BOUNDARY, user_action_); |
| 221 | user_action_ = ACTION_EXECUTE; |
| 222 | |
| 223 | delegate_->LogAction(ACTION_EXECUTE); |
| 224 | delegate_->PerformAction(*GetOrCreateExtensionList()); |
rdevlin.cronin | 9bd430a | 2015-05-08 18:06:18 | [diff] [blame] | 225 | |
| 226 | OnClose(); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 227 | } |
| 228 | |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 229 | void ExtensionMessageBubbleController::OnBubbleDismiss( |
| 230 | bool closed_by_deactivation) { |
[email protected] | a74569b | 2014-03-25 02:56:30 | [diff] [blame] | 231 | // OnBubbleDismiss() can be called twice when we receive multiple |
| 232 | // "OnWidgetDestroying" notifications (this can at least happen when we close |
| 233 | // a window with a notification open). Handle this gracefully. |
| 234 | if (user_action_ != ACTION_BOUNDARY) { |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 235 | DCHECK(user_action_ == ACTION_DISMISS_USER_ACTION || |
| 236 | user_action_ == ACTION_DISMISS_DEACTIVATION); |
[email protected] | a74569b | 2014-03-25 02:56:30 | [diff] [blame] | 237 | return; |
| 238 | } |
| 239 | |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 240 | user_action_ = closed_by_deactivation ? ACTION_DISMISS_DEACTIVATION |
| 241 | : ACTION_DISMISS_USER_ACTION; |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 242 | |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 243 | delegate_->LogAction(user_action_); |
rdevlin.cronin | 9bd430a | 2015-05-08 18:06:18 | [diff] [blame] | 244 | |
| 245 | OnClose(); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 246 | } |
| 247 | |
| 248 | void ExtensionMessageBubbleController::OnLinkClicked() { |
| 249 | DCHECK_EQ(ACTION_BOUNDARY, user_action_); |
| 250 | user_action_ = ACTION_LEARN_MORE; |
| 251 | |
| 252 | delegate_->LogAction(ACTION_LEARN_MORE); |
rdevlin.cronin | bb826f1 | 2016-06-22 21:30:05 | [diff] [blame] | 253 | // Opening a new tab for the learn more link can cause the bubble to close, so |
| 254 | // perform our cleanup here before opening the new tab. |
| 255 | OnClose(); |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 256 | if (!g_should_ignore_learn_more_for_testing) { |
Tim Judkins | 0c0936f5 | 2019-08-05 19:29:25 | [diff] [blame] | 257 | GURL learn_more_url = delegate_->GetLearnMoreUrl(); |
| 258 | DCHECK(learn_more_url.is_valid()); |
| 259 | browser_->OpenURL( |
| 260 | content::OpenURLParams(learn_more_url, content::Referrer(), |
| 261 | WindowOpenDisposition::NEW_FOREGROUND_TAB, |
| 262 | ui::PAGE_TRANSITION_LINK, false)); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 263 | } |
rdevlin.cronin | bb826f1 | 2016-06-22 21:30:05 | [diff] [blame] | 264 | // Warning: |this| may be deleted here! |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 265 | } |
| 266 | |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 267 | void ExtensionMessageBubbleController::SetIsActiveBubble() { |
| 268 | DCHECK(!is_active_bubble_); |
| 269 | DCHECK(!model_->has_active_bubble()); |
| 270 | is_active_bubble_ = true; |
| 271 | model_->set_has_active_bubble(true); |
| 272 | } |
| 273 | |
rdevlin.cronin | 0ba2a4c | 2015-08-06 18:40:19 | [diff] [blame] | 274 | // static |
| 275 | void ExtensionMessageBubbleController::set_should_ignore_learn_more_for_testing( |
| 276 | bool should_ignore) { |
| 277 | g_should_ignore_learn_more_for_testing = should_ignore; |
| 278 | } |
| 279 | |
Catherine Mullings | a889278 | 2017-09-06 23:45:50 | [diff] [blame] | 280 | void ExtensionMessageBubbleController::HandleExtensionUnloadOrUninstall() { |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 281 | UpdateExtensionIdList(); |
| 282 | // If the callback is set, then that means that OnShown() was called, and the |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 283 | // bubble was displayed. |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 284 | if (close_bubble_callback_ && GetExtensionIdList().empty()) { |
Daniel Cheng | d78c025 | 2019-04-26 17:22:11 | [diff] [blame] | 285 | std::move(close_bubble_callback_).Run(); |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 286 | } |
| 287 | // If the bubble refers to multiple extensions, we do not close the bubble. |
| 288 | } |
| 289 | |
Catherine Mullings | a889278 | 2017-09-06 23:45:50 | [diff] [blame] | 290 | void ExtensionMessageBubbleController::OnExtensionUnloaded( |
| 291 | content::BrowserContext* browser_context, |
| 292 | const Extension* extension, |
| 293 | UnloadedExtensionReason reason) { |
| 294 | HandleExtensionUnloadOrUninstall(); |
| 295 | } |
| 296 | |
| 297 | void ExtensionMessageBubbleController::OnExtensionUninstalled( |
| 298 | content::BrowserContext* browser_context, |
| 299 | const Extension* extension, |
| 300 | UninstallReason reason) { |
| 301 | HandleExtensionUnloadOrUninstall(); |
| 302 | } |
| 303 | |
Catherine Mullings | 8fe05b6 | 2017-08-16 17:14:45 | [diff] [blame] | 304 | void ExtensionMessageBubbleController::OnShutdown(ExtensionRegistry* registry) { |
| 305 | // It is possible that the extension registry is destroyed before the |
| 306 | // controller. In such case, the controller should no longer observe the |
| 307 | // registry. |
| 308 | extension_registry_observer_.Remove(registry); |
| 309 | } |
| 310 | |
rdevlin.cronin | 8937030 | 2016-04-19 14:24:40 | [diff] [blame] | 311 | void ExtensionMessageBubbleController::OnBrowserRemoved(Browser* browser) { |
Catherine Mullings | a2e975ff | 2017-08-29 00:45:06 | [diff] [blame] | 312 | extension_registry_observer_.RemoveAll(); |
rdevlin.cronin | af64c8c | 2016-06-21 00:16:00 | [diff] [blame] | 313 | if (browser == browser_) { |
| 314 | if (is_highlighting_) { |
| 315 | model_->StopHighlighting(); |
| 316 | is_highlighting_ = false; |
| 317 | } |
| 318 | if (is_active_bubble_) { |
| 319 | model_->set_has_active_bubble(false); |
| 320 | is_active_bubble_ = false; |
| 321 | } |
rdevlin.cronin | 8937030 | 2016-04-19 14:24:40 | [diff] [blame] | 322 | } |
| 323 | } |
| 324 | |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 325 | void ExtensionMessageBubbleController::AcknowledgeExtensions() { |
| 326 | ExtensionIdList* list = GetOrCreateExtensionList(); |
| 327 | for (ExtensionIdList::const_iterator it = list->begin(); |
| 328 | it != list->end(); ++it) |
| 329 | delegate_->AcknowledgeExtension(*it, user_action_); |
| 330 | } |
| 331 | |
| 332 | ExtensionIdList* ExtensionMessageBubbleController::GetOrCreateExtensionList() { |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 333 | if (!initialized_) { |
rdevlin.cronin | cce78d0 | 2015-09-24 19:50:55 | [diff] [blame] | 334 | ExtensionRegistry* registry = ExtensionRegistry::Get(profile()); |
dcheng | c963c714 | 2016-04-08 03:55:22 | [diff] [blame] | 335 | std::unique_ptr<const ExtensionSet> all_extensions; |
rdevlin.cronin | cce78d0 | 2015-09-24 19:50:55 | [diff] [blame] | 336 | if (!delegate_->ShouldLimitToEnabledExtensions()) |
| 337 | all_extensions = registry->GenerateInstalledExtensionsSet(); |
| 338 | const ExtensionSet& extensions_to_check = |
| 339 | all_extensions ? *all_extensions : registry->enabled_extensions(); |
| 340 | for (const scoped_refptr<const Extension>& extension : |
| 341 | extensions_to_check) { |
| 342 | if (delegate_->ShouldIncludeExtension(extension.get())) |
| 343 | extension_list_.push_back(extension->id()); |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 344 | } |
| 345 | |
| 346 | delegate_->LogExtensionCount(extension_list_.size()); |
| 347 | initialized_ = true; |
| 348 | } |
| 349 | |
| 350 | return &extension_list_; |
| 351 | } |
| 352 | |
rdevlin.cronin | 9bd430a | 2015-05-08 18:06:18 | [diff] [blame] | 353 | void ExtensionMessageBubbleController::OnClose() { |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 354 | DCHECK_NE(ACTION_BOUNDARY, user_action_); |
| 355 | // If the bubble was closed due to deactivation, don't treat it as |
| 356 | // acknowledgment so that the user will see the bubble again (until they |
| 357 | // explicitly take an action). |
rdevlin.cronin | cf27f866a | 2017-02-01 16:34:39 | [diff] [blame] | 358 | if (user_action_ != ACTION_DISMISS_DEACTIVATION || |
| 359 | delegate_->ShouldAcknowledgeOnDeactivate()) { |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 360 | AcknowledgeExtensions(); |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 361 | delegate_->OnAction(); |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 362 | } |
rdevlin.cronin | 9bd430a | 2015-05-08 18:06:18 | [diff] [blame] | 363 | |
Catherine Mullings | 478a043 | 2017-11-22 07:06:06 | [diff] [blame] | 364 | extension_registry_observer_.RemoveAll(); |
rdevlin.cronin | 486b20e | 2015-11-20 17:20:35 | [diff] [blame] | 365 | } |
| 366 | |
[email protected] | c72ebfe | 2013-12-13 21:57:53 | [diff] [blame] | 367 | } // namespace extensions |