Support remote installation of extensions and apps.

chrome/browser/extensions/extension_disabled_ui.cc

 // Copyright (c) 2012 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.
 
 #include "chrome/browser/extensions/extension_disabled_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
@@ skipping 123 matching lines @@
 }
 
 // ExtensionDisabledGlobalError -----------------------------------------------
 
 class ExtensionDisabledGlobalError : public GlobalErrorWithStandardBubble,
                                      public content::NotificationObserver,
                                      public ExtensionUninstallDialog::Delegate {
  public:
   ExtensionDisabledGlobalError(ExtensionService* service,
                                const Extension* extension,
+                               int disable_reasons,

[Yoyo Zhou, 2014/05/01 22:53:44]

Why not make this a bool is_remote_install?

[Marijn Kruisselbrink, 2014/05/05 20:45:36]

Done.

                                const gfx::Image& icon);
   virtual ~ExtensionDisabledGlobalError();
 
   // GlobalError implementation.
   virtual Severity GetSeverity() OVERRIDE;
   virtual bool HasMenuItem() OVERRIDE;
   virtual int MenuItemCommandID() OVERRIDE;
   virtual base::string16 MenuItemLabel() OVERRIDE;
   virtual void ExecuteMenuItem(Browser* browser) OVERRIDE;
   virtual gfx::Image GetBubbleViewIcon() OVERRIDE;
@@ skipping 10 matching lines @@
   virtual void ExtensionUninstallCanceled() OVERRIDE;
 
   // content::NotificationObserver implementation.
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
  private:
   ExtensionService* service_;
   const Extension* extension_;
+  int disable_reasons_;
   gfx::Image icon_;
 
   // How the user responded to the error; used for metrics.
   enum UserResponse {
     IGNORED,
     REENABLE,
     UNINSTALL,
     EXTENSION_DISABLED_UI_BUCKET_BOUNDARY
   };
   UserResponse user_response_;
 
   scoped_ptr<ExtensionUninstallDialog> uninstall_dialog_;
 
   // Menu command ID assigned for this extension's error.
   int menu_command_id_;
 
   content::NotificationRegistrar registrar_;
 };
 
 // TODO(yoz): create error at startup for disabled extensions.
 ExtensionDisabledGlobalError::ExtensionDisabledGlobalError(
     ExtensionService* service,
     const Extension* extension,
+    int disable_reasons,
     const gfx::Image& icon)
     : service_(service),
       extension_(extension),
+      disable_reasons_(disable_reasons),
       icon_(icon),
       user_response_(IGNORED),
       menu_command_id_(GetMenuCommandID()) {
   if (icon_.IsEmpty()) {
     icon_ = gfx::Image(
         gfx::ImageSkiaOperations::CreateResizedImage(
             extension_->is_app() ?
                 extensions::IconsInfo::GetDefaultAppIcon() :
                 extensions::IconsInfo::GetDefaultExtensionIcon(),
             skia::ImageOperations::RESIZE_BEST,
             gfx::Size(kIconSize, kIconSize)));
   }
   registrar_.Add(this,
                  chrome::NOTIFICATION_EXTENSION_LOADED_DEPRECATED,
                  content::Source<Profile>(service->profile()));
   registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_REMOVED,
                  content::Source<Profile>(service->profile()));
 }
 
 ExtensionDisabledGlobalError::~ExtensionDisabledGlobalError() {
   ReleaseMenuCommandID(menu_command_id_);
-  UMA_HISTOGRAM_ENUMERATION("Extensions.DisabledUIUserResponse",
-                            user_response_,
-                            EXTENSION_DISABLED_UI_BUCKET_BOUNDARY);
+  if (disable_reasons_ & Extension::DISABLE_REMOTE_INSTALL)

[Yoyo Zhou, 2014/05/01 22:53:44]

braces for more than one line if statements

[Marijn Kruisselbrink, 2014/05/05 20:45:36]

Done.

+    UMA_HISTOGRAM_ENUMERATION("Extensions.DisabledUIUserResponseRemoteInstall",
+                              user_response_,
+                              EXTENSION_DISABLED_UI_BUCKET_BOUNDARY);
+  else
+    UMA_HISTOGRAM_ENUMERATION("Extensions.DisabledUIUserResponse",
+                              user_response_,
+                              EXTENSION_DISABLED_UI_BUCKET_BOUNDARY);
 }
 
 GlobalError::Severity ExtensionDisabledGlobalError::GetSeverity() {
   return SEVERITY_LOW;
 }
 
 bool ExtensionDisabledGlobalError::HasMenuItem() {
   return true;
 }
 
 int ExtensionDisabledGlobalError::MenuItemCommandID() {
   return menu_command_id_;
 }
 
 base::string16 ExtensionDisabledGlobalError::MenuItemLabel() {
-  return l10n_util::GetStringFUTF16(IDS_EXTENSION_DISABLED_ERROR_TITLE,
-                                    base::UTF8ToUTF16(extension_->name()));
+  if (disable_reasons_ & Extension::DISABLE_REMOTE_INSTALL)
+    return l10n_util::GetStringFUTF16(
+        IDS_EXTENSION_DISABLED_REMOTE_INSTALL_ERROR_TITLE,
+        base::UTF8ToUTF16(extension_->name()));
+  else
+    return l10n_util::GetStringFUTF16(IDS_EXTENSION_DISABLED_ERROR_TITLE,
+                                      base::UTF8ToUTF16(extension_->name()));
 }
 
 void ExtensionDisabledGlobalError::ExecuteMenuItem(Browser* browser) {
   ShowBubbleView(browser);
 }
 
 gfx::Image ExtensionDisabledGlobalError::GetBubbleViewIcon() {
   return icon_;
 }
 
 base::string16 ExtensionDisabledGlobalError::GetBubbleViewTitle() {
-  return l10n_util::GetStringFUTF16(IDS_EXTENSION_DISABLED_ERROR_TITLE,
-                                    base::UTF8ToUTF16(extension_->name()));
+  if (disable_reasons_ & Extension::DISABLE_REMOTE_INSTALL)
+    return l10n_util::GetStringFUTF16(
+        IDS_EXTENSION_DISABLED_REMOTE_INSTALL_ERROR_TITLE,
+        base::UTF8ToUTF16(extension_->name()));
+  else
+    return l10n_util::GetStringFUTF16(IDS_EXTENSION_DISABLED_ERROR_TITLE,
+                                      base::UTF8ToUTF16(extension_->name()));
 }
 
 std::vector<base::string16>
 ExtensionDisabledGlobalError::GetBubbleViewMessages() {
   std::vector<base::string16> messages;
-  messages.push_back(l10n_util::GetStringFUTF16(
-      extension_->is_app() ?
-      IDS_APP_DISABLED_ERROR_LABEL : IDS_EXTENSION_DISABLED_ERROR_LABEL,
-      base::UTF8ToUTF16(extension_->name())));
-  messages.push_back(l10n_util::GetStringUTF16(
-      IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO));
   std::vector<base::string16> permission_warnings =
       extensions::PermissionMessageProvider::Get()->GetWarningMessages(
           extension_->GetActivePermissions(), extension_->GetType());
+  if (disable_reasons_ & Extension::DISABLE_REMOTE_INSTALL) {
+    messages.push_back(l10n_util::GetStringFUTF16(
+        extension_->is_app()
+            ? IDS_APP_DISABLED_REMOTE_INSTALL_ERROR_LABEL
+            : IDS_EXTENSION_DISABLED_REMOTE_INSTALL_ERROR_LABEL,
+        base::UTF8ToUTF16(extension_->name())));
+    if (!permission_warnings.empty())
+      messages.push_back(
+          l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO));
+  } else {
+    messages.push_back(l10n_util::GetStringFUTF16(

[Yoyo Zhou, 2014/05/01 22:53:44]

There is some redundancy here. Consider making it less so.

[Marijn Kruisselbrink, 2014/05/05 20:45:36]

I'm not sure what redundancy there is? Even ExtensionInstallPrompt, which mostly
uses lookup tables when different strings need to be used for different
situations still uses separate code for the few cases where the string also
varies for app vs extension.

I guess one thing that might be slightly cleaner is to add getters for the
caption and permission header strings. Is that what you mean?

[Yoyo Zhou, 2014/05/05 22:35:17]

Ah, I misread. These are not the same strings. Sorry about that.

+        extension_->is_app() ? IDS_APP_DISABLED_ERROR_LABEL
+                             : IDS_EXTENSION_DISABLED_ERROR_LABEL,
+        base::UTF8ToUTF16(extension_->name())));
+    messages.push_back(l10n_util::GetStringUTF16(
+        IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO));
+  }
   for (size_t i = 0; i < permission_warnings.size(); ++i) {
     messages.push_back(l10n_util::GetStringFUTF16(
         IDS_EXTENSION_PERMISSION_LINE, permission_warnings[i]));
   }
   return messages;
 }
 
 base::string16 ExtensionDisabledGlobalError::GetBubbleViewAcceptButtonLabel() {
-  return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON);
+  if (disable_reasons_ & Extension::DISABLE_REMOTE_INSTALL)
+    return l10n_util::GetStringUTF16(
+        IDS_EXTENSION_PROMPT_REMOTE_INSTALL_BUTTON);
+  else
+    return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON);
 }
 
 base::string16 ExtensionDisabledGlobalError::GetBubbleViewCancelButtonLabel() {
   return l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNINSTALL);
 }
 
 void ExtensionDisabledGlobalError::OnBubbleViewDidClose(Browser* browser) {
 }
 
 void ExtensionDisabledGlobalError::BubbleViewAcceptButtonPressed(
@@ skipping 44 matching lines @@
     user_response_ = UNINSTALL;
   delete this;
 }
 
 // Globals --------------------------------------------------------------------
 
 namespace extensions {
 
 void AddExtensionDisabledErrorWithIcon(base::WeakPtr<ExtensionService> service,
                                        const std::string& extension_id,
+                                       int disable_reasons,
                                        const gfx::Image& icon) {
   if (!service.get())
     return;
   const Extension* extension = service->GetInstalledExtension(extension_id);
   if (extension) {
     GlobalErrorServiceFactory::GetForProfile(service->profile())
-        ->AddGlobalError(
-              new ExtensionDisabledGlobalError(service.get(), extension, icon));
+        ->AddGlobalError(new ExtensionDisabledGlobalError(
+            service.get(), extension, disable_reasons, icon));
   }
 }
 
 void AddExtensionDisabledError(ExtensionService* service,
-                               const Extension* extension) {
+                               const Extension* extension,
+                               int disable_reasons) {
   // Do not display notifications for ephemeral apps that have been disabled.
   // Instead, a prompt will be shown the next time the app is launched.
   if (extension->is_ephemeral())
     return;
 
   extensions::ExtensionResource image = extensions::IconsInfo::GetIconResource(
       extension, kIconSize, ExtensionIconSet::MATCH_BIGGER);
   gfx::Size size(kIconSize, kIconSize);
-  ImageLoader::Get(service->profile())->LoadImageAsync(
-      extension, image, size,
-      base::Bind(&AddExtensionDisabledErrorWithIcon,
-                 service->AsWeakPtr(), extension->id()));
+  ImageLoader::Get(service->profile())
+      ->LoadImageAsync(extension,
+                       image,
+                       size,
+                       base::Bind(&AddExtensionDisabledErrorWithIcon,
+                                  service->AsWeakPtr(),
+                                  extension->id(),
+                                  disable_reasons));
 }
 
 void ShowExtensionDisabledDialog(ExtensionService* service,
                                  content::WebContents* web_contents,
                                  const Extension* extension) {
   scoped_ptr<ExtensionInstallPrompt> install_ui(
       new ExtensionInstallPrompt(web_contents));
   // This object manages its own lifetime.
   new ExtensionDisabledDialogDelegate(service, install_ui.Pass(), extension);
 }
 
 }  // namespace extensions