1 // Copyright 2014 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/external_install_ui.h"
6
7 #include <string>
8
9 #include "base/bind.h"
10 #include "base/lazy_instance.h"
11 #include "base/memory/ref_counted.h"
12 #include "base/memory/scoped_ptr.h"
13 #include "base/message_loop/message_loop.h"
14 #include "base/metrics/histogram.h"
15 #include "base/scoped_observer.h"
16 #include "base/strings/utf_string_conversions.h"
17 #include "chrome/app/chrome_command_ids.h"
18 #include "chrome/browser/chrome_notification_types.h"
19 #include "chrome/browser/extensions/extension_install_prompt.h"
20 #include "chrome/browser/extensions/extension_install_ui.h"
21 #include "chrome/browser/extensions/extension_service.h"
22 #include "chrome/browser/extensions/extension_uninstall_dialog.h"
23 #include "chrome/browser/extensions/webstore_data_fetcher.h"
24 #include "chrome/browser/extensions/webstore_data_fetcher_delegate.h"
25 #include "chrome/browser/profiles/profile.h"
26 #include "chrome/browser/ui/browser.h"
27 #include "chrome/browser/ui/browser_finder.h"
28 #include "chrome/browser/ui/global_error/global_error.h"
29 #include "chrome/browser/ui/global_error/global_error_service.h"
30 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
31 #include "chrome/common/extensions/manifest_url_handler.h"
32 #include "content/public/browser/notification_details.h"
33 #include "content/public/browser/notification_observer.h"
34 #include "content/public/browser/notification_registrar.h"
35 #include "content/public/browser/notification_source.h"
36 #include "extensions/browser/extension_registry.h"
37 #include "extensions/browser/extension_registry_observer.h"
38 #include "extensions/common/constants.h"
39 #include "grit/generated_resources.h"
40 #include "ui/base/l10n/l10n_util.h"
41 #include "ui/gfx/image/image.h"
42 #include "ui/gfx/image/image_skia_operations.h"
43
44 namespace extensions {
45
46 namespace {
47
48 // Whether the external extension can use the streamlined bubble install flow.
UseBubbleInstall(const Extension * extension,bool is_new_profile)49 bool UseBubbleInstall(const Extension* extension, bool is_new_profile) {
50 return ManifestURL::UpdatesFromGallery(extension) && !is_new_profile;
51 }
52
53 } // namespace
54
55 static const int kMenuCommandId = IDC_EXTERNAL_EXTENSION_ALERT;
56
57 class ExternalInstallGlobalError;
58
59 namespace extensions {
60 class ExtensionRegistry;
61 }
62
63 // This class is refcounted to stay alive while we try and pull webstore data.
64 class ExternalInstallDialogDelegate
65 : public ExtensionInstallPrompt::Delegate,
66 public WebstoreDataFetcherDelegate,
67 public content::NotificationObserver,
68 public base::RefCountedThreadSafe<ExternalInstallDialogDelegate> {
69 public:
70 ExternalInstallDialogDelegate(Browser* browser,
71 ExtensionService* service,
72 const Extension* extension,
73 bool use_global_error);
74
browser()75 Browser* browser() { return browser_; }
76
77 private:
78 friend class base::RefCountedThreadSafe<ExternalInstallDialogDelegate>;
79 friend class ExternalInstallGlobalError;
80
81 virtual ~ExternalInstallDialogDelegate();
82
83 // ExtensionInstallPrompt::Delegate:
84 virtual void InstallUIProceed() OVERRIDE;
85 virtual void InstallUIAbort(bool user_initiated) OVERRIDE;
86
87 // WebstoreDataFetcherDelegate:
88 virtual void OnWebstoreRequestFailure() OVERRIDE;
89 virtual void OnWebstoreResponseParseSuccess(
90 scoped_ptr<base::DictionaryValue> webstore_data) OVERRIDE;
91 virtual void OnWebstoreResponseParseFailure(
92 const std::string& error) OVERRIDE;
93
94 // content::NotificationObserver:
95 virtual void Observe(int type,
96 const content::NotificationSource& source,
97 const content::NotificationDetails& details) OVERRIDE;
98
99 // Show the install dialog to the user.
100 void ShowInstallUI();
101
102 // The UI for showing the install dialog when enabling.
103 scoped_ptr<ExtensionInstallPrompt> install_ui_;
104 scoped_refptr<ExtensionInstallPrompt::Prompt> prompt_;
105
106 Browser* browser_;
107 base::WeakPtr<ExtensionService> service_weak_;
108 scoped_ptr<WebstoreDataFetcher> webstore_data_fetcher_;
109 content::NotificationRegistrar registrar_;
110 std::string extension_id_;
111 bool use_global_error_;
112
113 DISALLOW_COPY_AND_ASSIGN(ExternalInstallDialogDelegate);
114 };
115
116 // Only shows a menu item, no bubble. Clicking the menu item shows
117 // an external install dialog.
118 class ExternalInstallMenuAlert : public GlobalErrorWithStandardBubble,
119 public content::NotificationObserver,
120 public ExtensionRegistryObserver {
121 public:
122 ExternalInstallMenuAlert(ExtensionService* service,
123 const Extension* extension);
124 virtual ~ExternalInstallMenuAlert();
125
126 // GlobalError implementation.
127 virtual Severity GetSeverity() OVERRIDE;
128 virtual bool HasMenuItem() OVERRIDE;
129 virtual int MenuItemCommandID() OVERRIDE;
130 virtual base::string16 MenuItemLabel() OVERRIDE;
131 virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
132 virtual bool HasBubbleView() OVERRIDE;
133 virtual base::string16 GetBubbleViewTitle() OVERRIDE;
134 virtual std::vector<base::string16> GetBubbleViewMessages() OVERRIDE;
135 virtual base::string16 GetBubbleViewAcceptButtonLabel() OVERRIDE;
136 virtual base::string16 GetBubbleViewCancelButtonLabel() OVERRIDE;
137 virtual void OnBubbleViewDidClose(Browser* browser) OVERRIDE;
138 virtual void BubbleViewAcceptButtonPressed(Browser* browser) OVERRIDE;
139 virtual void BubbleViewCancelButtonPressed(Browser* browser) OVERRIDE;
140
141 protected:
142 ExtensionService* service_;
143 const Extension* extension_;
144
145 private:
146 // Delete this instance after cleaning jobs.
147 void Clean();
148
149 // content::NotificationObserver implementation.
150 virtual void Observe(int type,
151 const content::NotificationSource& source,
152 const content::NotificationDetails& details) OVERRIDE;
153
154 // ExtensionRegistryObserver implementation.
155 virtual void OnExtensionLoaded(content::BrowserContext* browser_context,
156 const Extension* extension) OVERRIDE;
157
158 content::NotificationRegistrar registrar_;
159
160 // Listen to extension load notifications.
161 ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
162 extension_registry_observer_;
163
164 DISALLOW_COPY_AND_ASSIGN(ExternalInstallMenuAlert);
165 };
166
167 // Shows a menu item and a global error bubble, replacing the install dialog.
168 class ExternalInstallGlobalError : public ExternalInstallMenuAlert {
169 public:
170 ExternalInstallGlobalError(
171 ExtensionService* service,
172 const Extension* extension,
173 ExternalInstallDialogDelegate* delegate,
174 scoped_refptr<ExtensionInstallPrompt::Prompt> prompt);
175 virtual ~ExternalInstallGlobalError();
176
177 virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
178 virtual bool HasBubbleView() OVERRIDE;
179 virtual gfx::Image GetBubbleViewIcon() OVERRIDE;
180 virtual base::string16 GetBubbleViewTitle() OVERRIDE;
181 virtual std::vector<base::string16> GetBubbleViewMessages() OVERRIDE;
182 virtual base::string16 GetBubbleViewAcceptButtonLabel() OVERRIDE;
183 virtual base::string16 GetBubbleViewCancelButtonLabel() OVERRIDE;
184 virtual void OnBubbleViewDidClose(Browser* browser) OVERRIDE;
185 virtual void BubbleViewAcceptButtonPressed(Browser* browser) OVERRIDE;
186 virtual void BubbleViewCancelButtonPressed(Browser* browser) OVERRIDE;
187
188 protected:
189 // Ref-counted, but needs to be disposed of if we are dismissed without
190 // having been clicked (perhaps because the user enabled the extension
191 // manually).
192 ExternalInstallDialogDelegate* delegate_;
193 scoped_refptr<ExtensionInstallPrompt::Prompt> prompt_;
194
195 private:
196 DISALLOW_COPY_AND_ASSIGN(ExternalInstallGlobalError);
197 };
198
CreateExternalInstallGlobalError(base::WeakPtr<ExtensionService> service,const std::string & extension_id,const ExtensionInstallPrompt::ShowParams & show_params,ExtensionInstallPrompt::Delegate * prompt_delegate,scoped_refptr<ExtensionInstallPrompt::Prompt> prompt)199 static void CreateExternalInstallGlobalError(
200 base::WeakPtr<ExtensionService> service,
201 const std::string& extension_id,
202 const ExtensionInstallPrompt::ShowParams& show_params,
203 ExtensionInstallPrompt::Delegate* prompt_delegate,
204 scoped_refptr<ExtensionInstallPrompt::Prompt> prompt) {
205 if (!service.get())
206 return;
207 const Extension* extension = service->GetInstalledExtension(extension_id);
208 if (!extension)
209 return;
210 GlobalErrorService* error_service =
211 GlobalErrorServiceFactory::GetForProfile(service->profile());
212 if (error_service->GetGlobalErrorByMenuItemCommandID(kMenuCommandId))
213 return;
214
215 ExternalInstallDialogDelegate* delegate =
216 static_cast<ExternalInstallDialogDelegate*>(prompt_delegate);
217 ExternalInstallGlobalError* error_bubble = new ExternalInstallGlobalError(
218 service.get(), extension, delegate, prompt);
219 error_service->AddGlobalError(error_bubble);
220 // Show bubble immediately if possible.
221 if (delegate->browser())
222 error_bubble->ShowBubbleView(delegate->browser());
223 }
224
ShowExternalInstallDialog(ExtensionService * service,Browser * browser,const Extension * extension)225 static void ShowExternalInstallDialog(
226 ExtensionService* service,
227 Browser* browser,
228 const Extension* extension) {
229 // This object manages its own lifetime.
230 new ExternalInstallDialogDelegate(browser, service, extension, false);
231 }
232
233 // ExternalInstallDialogDelegate --------------------------------------------
234
ExternalInstallDialogDelegate(Browser * browser,ExtensionService * service,const Extension * extension,bool use_global_error)235 ExternalInstallDialogDelegate::ExternalInstallDialogDelegate(
236 Browser* browser,
237 ExtensionService* service,
238 const Extension* extension,
239 bool use_global_error)
240 : browser_(browser),
241 service_weak_(service->AsWeakPtr()),
242 extension_id_(extension->id()),
243 use_global_error_(use_global_error) {
244 AddRef(); // Balanced in Proceed or Abort.
245
246 prompt_ = new ExtensionInstallPrompt::Prompt(
247 ExtensionInstallPrompt::EXTERNAL_INSTALL_PROMPT);
248
249 // If we don't have a browser, we can't go to the webstore to fetch data.
250 // This should only happen in tests.
251 if (!browser) {
252 ShowInstallUI();
253 return;
254 }
255
256 // Make sure to be notified if the owning profile is destroyed.
257 registrar_.Add(this,
258 chrome::NOTIFICATION_PROFILE_DESTROYED,
259 content::Source<Profile>(browser->profile()));
260
261 webstore_data_fetcher_.reset(new WebstoreDataFetcher(
262 this,
263 browser->profile()->GetRequestContext(),
264 GURL::EmptyGURL(),
265 extension->id()));
266 webstore_data_fetcher_->Start();
267 }
268
OnWebstoreRequestFailure()269 void ExternalInstallDialogDelegate::OnWebstoreRequestFailure() {
270 ShowInstallUI();
271 }
272
OnWebstoreResponseParseSuccess(scoped_ptr<base::DictionaryValue> webstore_data)273 void ExternalInstallDialogDelegate::OnWebstoreResponseParseSuccess(
274 scoped_ptr<base::DictionaryValue> webstore_data) {
275 std::string localized_user_count;
276 double average_rating;
277 int rating_count;
278 if (!webstore_data->GetString(kUsersKey, &localized_user_count) ||
279 !webstore_data->GetDouble(kAverageRatingKey, &average_rating) ||
280 !webstore_data->GetInteger(kRatingCountKey, &rating_count)) {
281 // If we don't get a valid webstore response, short circuit, and continue
282 // to show a prompt without webstore data.
283 ShowInstallUI();
284 return;
285 }
286
287 bool show_user_count = true;
288 webstore_data->GetBoolean(kShowUserCountKey, &show_user_count);
289
290 prompt_->SetWebstoreData(localized_user_count,
291 show_user_count,
292 average_rating,
293 rating_count);
294
295 ShowInstallUI();
296 }
297
OnWebstoreResponseParseFailure(const std::string & error)298 void ExternalInstallDialogDelegate::OnWebstoreResponseParseFailure(
299 const std::string& error) {
300 ShowInstallUI();
301 }
302
Observe(int type,const content::NotificationSource & source,const content::NotificationDetails & details)303 void ExternalInstallDialogDelegate::Observe(
304 int type,
305 const content::NotificationSource& source,
306 const content::NotificationDetails& details) {
307 DCHECK_EQ(type, chrome::NOTIFICATION_PROFILE_DESTROYED);
308 // If the owning profile is destroyed, we need to abort so that we don't leak.
309 InstallUIAbort(false); // Not user initiated.
310 }
311
ShowInstallUI()312 void ExternalInstallDialogDelegate::ShowInstallUI() {
313 const Extension* extension = NULL;
314 if (!service_weak_.get() ||
315 !(extension = service_weak_->GetInstalledExtension(extension_id_))) {
316 return;
317 }
318 install_ui_.reset(
319 ExtensionInstallUI::CreateInstallPromptWithBrowser(browser_));
320
321 const ExtensionInstallPrompt::ShowDialogCallback callback =
322 use_global_error_ ?
323 base::Bind(&CreateExternalInstallGlobalError,
324 service_weak_,
325 extension_id_) :
326 ExtensionInstallPrompt::GetDefaultShowDialogCallback();
327
328 install_ui_->ConfirmExternalInstall(this, extension, callback, prompt_);
329 }
330
~ExternalInstallDialogDelegate()331 ExternalInstallDialogDelegate::~ExternalInstallDialogDelegate() {
332 }
333
InstallUIProceed()334 void ExternalInstallDialogDelegate::InstallUIProceed() {
335 const Extension* extension = NULL;
336 if (service_weak_.get() &&
337 (extension = service_weak_->GetInstalledExtension(extension_id_))) {
338 service_weak_->GrantPermissionsAndEnableExtension(extension);
339 }
340 Release();
341 }
342
InstallUIAbort(bool user_initiated)343 void ExternalInstallDialogDelegate::InstallUIAbort(bool user_initiated) {
344 const Extension* extension = NULL;
345
346 // Uninstall the extension if the abort was user initiated (and not, e.g., the
347 // result of the window closing).
348 // Otherwise, the extension will remain installed, but unacknowledged, so it
349 // will be prompted again.
350 if (user_initiated &&
351 service_weak_.get() &&
352 (extension = service_weak_->GetInstalledExtension(extension_id_))) {
353 service_weak_->UninstallExtension(extension_id_, false, NULL);
354 }
355 Release();
356 }
357
358 // ExternalInstallMenuAlert -------------------------------------------------
359
ExternalInstallMenuAlert(ExtensionService * service,const Extension * extension)360 ExternalInstallMenuAlert::ExternalInstallMenuAlert(ExtensionService* service,
361 const Extension* extension)
362 : service_(service),
363 extension_(extension),
364 extension_registry_observer_(this) {
365 extension_registry_observer_.Add(ExtensionRegistry::Get(service->profile()));
366 registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_REMOVED,
367 content::Source<Profile>(service->profile()));
368 }
369
~ExternalInstallMenuAlert()370 ExternalInstallMenuAlert::~ExternalInstallMenuAlert() {
371 }
372
GetSeverity()373 GlobalError::Severity ExternalInstallMenuAlert::GetSeverity() {
374 return SEVERITY_LOW;
375 }
376
HasMenuItem()377 bool ExternalInstallMenuAlert::HasMenuItem() {
378 return true;
379 }
380
MenuItemCommandID()381 int ExternalInstallMenuAlert::MenuItemCommandID() {
382 return kMenuCommandId;
383 }
384
MenuItemLabel()385 base::string16 ExternalInstallMenuAlert::MenuItemLabel() {
386 int id = -1;
387 if (extension_->is_app())
388 id = IDS_EXTENSION_EXTERNAL_INSTALL_ALERT_APP;
389 else if (extension_->is_theme())
390 id = IDS_EXTENSION_EXTERNAL_INSTALL_ALERT_THEME;
391 else
392 id = IDS_EXTENSION_EXTERNAL_INSTALL_ALERT_EXTENSION;
393 return l10n_util::GetStringFUTF16(id, base::UTF8ToUTF16(extension_->name()));
394 }
395
ExecuteMenuItem(Browser * browser)396 void ExternalInstallMenuAlert::ExecuteMenuItem(Browser* browser) {
397 ShowExternalInstallDialog(service_, browser, extension_);
398 }
399
HasBubbleView()400 bool ExternalInstallMenuAlert::HasBubbleView() {
401 return false;
402 }
GetBubbleViewTitle()403 base::string16 ExternalInstallMenuAlert::GetBubbleViewTitle() {
404 return base::string16();
405 }
406
GetBubbleViewMessages()407 std::vector<base::string16> ExternalInstallMenuAlert::GetBubbleViewMessages() {
408 return std::vector<base::string16>();
409 }
410
GetBubbleViewAcceptButtonLabel()411 base::string16 ExternalInstallMenuAlert::GetBubbleViewAcceptButtonLabel() {
412 return base::string16();
413 }
414
GetBubbleViewCancelButtonLabel()415 base::string16 ExternalInstallMenuAlert::GetBubbleViewCancelButtonLabel() {
416 return base::string16();
417 }
418
OnBubbleViewDidClose(Browser * browser)419 void ExternalInstallMenuAlert::OnBubbleViewDidClose(Browser* browser) {
420 NOTREACHED();
421 }
422
BubbleViewAcceptButtonPressed(Browser * browser)423 void ExternalInstallMenuAlert::BubbleViewAcceptButtonPressed(
424 Browser* browser) {
425 NOTREACHED();
426 }
427
BubbleViewCancelButtonPressed(Browser * browser)428 void ExternalInstallMenuAlert::BubbleViewCancelButtonPressed(
429 Browser* browser) {
430 NOTREACHED();
431 }
432
OnExtensionLoaded(content::BrowserContext * browser_context,const Extension * extension)433 void ExternalInstallMenuAlert::OnExtensionLoaded(
434 content::BrowserContext* browser_context,
435 const Extension* extension) {
436 if (extension == extension_)
437 Clean();
438 }
439
Observe(int type,const content::NotificationSource & source,const content::NotificationDetails & details)440 void ExternalInstallMenuAlert::Observe(
441 int type,
442 const content::NotificationSource& source,
443 const content::NotificationDetails& details) {
444 // The error is invalidated if the extension has been loaded or removed.
445 DCHECK_EQ(type, chrome::NOTIFICATION_EXTENSION_REMOVED);
446 const Extension* extension = content::Details<const Extension>(details).ptr();
447 if (extension == extension_)
448 Clean();
449 }
450
Clean()451 void ExternalInstallMenuAlert::Clean() {
452 GlobalErrorService* error_service =
453 GlobalErrorServiceFactory::GetForProfile(service_->profile());
454 error_service->RemoveGlobalError(this);
455 service_->AcknowledgeExternalExtension(extension_->id());
456 delete this;
457 }
458
459 // ExternalInstallGlobalError -----------------------------------------------
460
ExternalInstallGlobalError(ExtensionService * service,const Extension * extension,ExternalInstallDialogDelegate * delegate,scoped_refptr<ExtensionInstallPrompt::Prompt> prompt)461 ExternalInstallGlobalError::ExternalInstallGlobalError(
462 ExtensionService* service,
463 const Extension* extension,
464 ExternalInstallDialogDelegate* delegate,
465 scoped_refptr<ExtensionInstallPrompt::Prompt> prompt)
466 : ExternalInstallMenuAlert(service, extension),
467 delegate_(delegate),
468 prompt_(prompt) {
469 }
470
~ExternalInstallGlobalError()471 ExternalInstallGlobalError::~ExternalInstallGlobalError() {
472 if (delegate_)
473 delegate_->Release();
474 }
475
ExecuteMenuItem(Browser * browser)476 void ExternalInstallGlobalError::ExecuteMenuItem(Browser* browser) {
477 ShowBubbleView(browser);
478 }
479
HasBubbleView()480 bool ExternalInstallGlobalError::HasBubbleView() {
481 return true;
482 }
483
GetBubbleViewIcon()484 gfx::Image ExternalInstallGlobalError::GetBubbleViewIcon() {
485 if (prompt_->icon().IsEmpty())
486 return GlobalErrorWithStandardBubble::GetBubbleViewIcon();
487 // Scale icon to a reasonable size.
488 return gfx::Image(gfx::ImageSkiaOperations::CreateResizedImage(
489 *prompt_->icon().ToImageSkia(),
490 skia::ImageOperations::RESIZE_BEST,
491 gfx::Size(extension_misc::EXTENSION_ICON_SMALL,
492 extension_misc::EXTENSION_ICON_SMALL)));
493 }
494
GetBubbleViewTitle()495 base::string16 ExternalInstallGlobalError::GetBubbleViewTitle() {
496 return prompt_->GetDialogTitle();
497 }
498
499 std::vector<base::string16>
GetBubbleViewMessages()500 ExternalInstallGlobalError::GetBubbleViewMessages() {
501 std::vector<base::string16> messages;
502 messages.push_back(prompt_->GetHeading());
503 if (prompt_->GetPermissionCount()) {
504 messages.push_back(prompt_->GetPermissionsHeading());
505 for (size_t i = 0; i < prompt_->GetPermissionCount(); ++i) {
506 messages.push_back(l10n_util::GetStringFUTF16(
507 IDS_EXTENSION_PERMISSION_LINE,
508 prompt_->GetPermission(i)));
509 }
510 }
511 // TODO(yoz): OAuth issue advice?
512 return messages;
513 }
514
GetBubbleViewAcceptButtonLabel()515 base::string16 ExternalInstallGlobalError::GetBubbleViewAcceptButtonLabel() {
516 return prompt_->GetAcceptButtonLabel();
517 }
518
GetBubbleViewCancelButtonLabel()519 base::string16 ExternalInstallGlobalError::GetBubbleViewCancelButtonLabel() {
520 return prompt_->GetAbortButtonLabel();
521 }
522
OnBubbleViewDidClose(Browser * browser)523 void ExternalInstallGlobalError::OnBubbleViewDidClose(Browser* browser) {
524 }
525
BubbleViewAcceptButtonPressed(Browser * browser)526 void ExternalInstallGlobalError::BubbleViewAcceptButtonPressed(
527 Browser* browser) {
528 ExternalInstallDialogDelegate* delegate = delegate_;
529 delegate_ = NULL;
530 delegate->InstallUIProceed();
531 }
532
BubbleViewCancelButtonPressed(Browser * browser)533 void ExternalInstallGlobalError::BubbleViewCancelButtonPressed(
534 Browser* browser) {
535 ExternalInstallDialogDelegate* delegate = delegate_;
536 delegate_ = NULL;
537 delegate->InstallUIAbort(true);
538 }
539
540 // Public interface ---------------------------------------------------------
541
AddExternalInstallError(ExtensionService * service,const Extension * extension,bool is_new_profile)542 void AddExternalInstallError(ExtensionService* service,
543 const Extension* extension,
544 bool is_new_profile) {
545 GlobalErrorService* error_service =
546 GlobalErrorServiceFactory::GetForProfile(service->profile());
547 if (error_service->GetGlobalErrorByMenuItemCommandID(kMenuCommandId))
548 return;
549
550 if (UseBubbleInstall(extension, is_new_profile)) {
551 Browser* browser = NULL;
552 #if !defined(OS_ANDROID)
553 browser = chrome::FindTabbedBrowser(service->profile(),
554 true,
555 chrome::GetActiveDesktop());
556 #endif
557 new ExternalInstallDialogDelegate(browser, service, extension, true);
558 } else {
559 error_service->AddGlobalError(
560 new ExternalInstallMenuAlert(service, extension));
561 }
562 }
563
RemoveExternalInstallError(ExtensionService * service)564 void RemoveExternalInstallError(ExtensionService* service) {
565 GlobalErrorService* error_service =
566 GlobalErrorServiceFactory::GetForProfile(service->profile());
567 GlobalError* error = error_service->GetGlobalErrorByMenuItemCommandID(
568 kMenuCommandId);
569 if (error) {
570 error_service->RemoveGlobalError(error);
571 delete error;
572 }
573 }
574
HasExternalInstallError(ExtensionService * service)575 bool HasExternalInstallError(ExtensionService* service) {
576 GlobalErrorService* error_service =
577 GlobalErrorServiceFactory::GetForProfile(service->profile());
578 GlobalError* error = error_service->GetGlobalErrorByMenuItemCommandID(
579 kMenuCommandId);
580 return !!error;
581 }
582
HasExternalInstallBubble(ExtensionService * service)583 bool HasExternalInstallBubble(ExtensionService* service) {
584 GlobalErrorService* error_service =
585 GlobalErrorServiceFactory::GetForProfile(service->profile());
586 GlobalError* error = error_service->GetGlobalErrorByMenuItemCommandID(
587 kMenuCommandId);
588 return error && error->HasBubbleView();
589 }
590
591 } // namespace extensions
592