src/chrome/browser/extensions/external_install_ui.cc

   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.
  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
  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
 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
 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
 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
 269 void ExternalInstallDialogDelegate::OnWebstoreRequestFailure() {
 270   ShowInstallUI();
 271 }
 272
 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
 298 void ExternalInstallDialogDelegate::OnWebstoreResponseParseFailure(
 299     const std::string& error) {
 300   ShowInstallUI();
 301 }
 302
 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
 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
 331 ExternalInstallDialogDelegate::~ExternalInstallDialogDelegate() {
 332 }
 333
 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
 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
 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
 370 ExternalInstallMenuAlert::~ExternalInstallMenuAlert() {
 371 }
 372
 373 GlobalError::Severity ExternalInstallMenuAlert::GetSeverity() {
 374   return SEVERITY_LOW;
 375 }
 376
 377 bool ExternalInstallMenuAlert::HasMenuItem() {
 378   return true;
 379 }
 380
 381 int ExternalInstallMenuAlert::MenuItemCommandID() {
 382   return kMenuCommandId;
 383 }
 384
 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
 396 void ExternalInstallMenuAlert::ExecuteMenuItem(Browser* browser) {
 397   ShowExternalInstallDialog(service_, browser, extension_);
 398 }
 399
 400 bool ExternalInstallMenuAlert::HasBubbleView() {
 401   return false;
 402 }
 403 base::string16 ExternalInstallMenuAlert::GetBubbleViewTitle() {
 404   return base::string16();
 405 }
 406
 407 std::vector<base::string16> ExternalInstallMenuAlert::GetBubbleViewMessages() {
 408   return std::vector<base::string16>();
 409 }
 410
 411 base::string16 ExternalInstallMenuAlert::GetBubbleViewAcceptButtonLabel() {
 412   return base::string16();
 413 }
 414
 415 base::string16 ExternalInstallMenuAlert::GetBubbleViewCancelButtonLabel() {
 416   return base::string16();
 417 }
 418
 419 void ExternalInstallMenuAlert::OnBubbleViewDidClose(Browser* browser) {
 420   NOTREACHED();
 421 }
 422
 423 void ExternalInstallMenuAlert::BubbleViewAcceptButtonPressed(
 424     Browser* browser) {
 425   NOTREACHED();
 426 }
 427
 428 void ExternalInstallMenuAlert::BubbleViewCancelButtonPressed(
 429     Browser* browser) {
 430   NOTREACHED();
 431 }
 432
 433 void ExternalInstallMenuAlert::OnExtensionLoaded(
 434     content::BrowserContext* browser_context,
 435     const Extension* extension) {
 436   if (extension == extension_)
 437     Clean();
 438 }
 439
 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
 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
 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
 471 ExternalInstallGlobalError::~ExternalInstallGlobalError() {
 472   if (delegate_)
 473     delegate_->Release();
 474 }
 475
 476 void ExternalInstallGlobalError::ExecuteMenuItem(Browser* browser) {
 477   ShowBubbleView(browser);
 478 }
 479
 480 bool ExternalInstallGlobalError::HasBubbleView() {
 481   return true;
 482 }
 483
 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
 495 base::string16 ExternalInstallGlobalError::GetBubbleViewTitle() {
 496   return prompt_->GetDialogTitle();
 497 }
 498
 499 std::vector<base::string16>
 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
 515 base::string16 ExternalInstallGlobalError::GetBubbleViewAcceptButtonLabel() {
 516   return prompt_->GetAcceptButtonLabel();
 517 }
 518
 519 base::string16 ExternalInstallGlobalError::GetBubbleViewCancelButtonLabel() {
 520   return prompt_->GetAbortButtonLabel();
 521 }
 522
 523 void ExternalInstallGlobalError::OnBubbleViewDidClose(Browser* browser) {
 524 }
 525
 526 void ExternalInstallGlobalError::BubbleViewAcceptButtonPressed(
 527     Browser* browser) {
 528   ExternalInstallDialogDelegate* delegate = delegate_;
 529   delegate_ = NULL;
 530   delegate->InstallUIProceed();
 531 }
 532
 533 void ExternalInstallGlobalError::BubbleViewCancelButtonPressed(
 534     Browser* browser) {
 535   ExternalInstallDialogDelegate* delegate = delegate_;
 536   delegate_ = NULL;
 537   delegate->InstallUIAbort(true);
 538 }
 539
 540 // Public interface ---------------------------------------------------------
 541
 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
 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
 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
 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