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 124 matching lines @@
 }
 
 // ExtensionDisabledGlobalError -----------------------------------------------
 
 class ExtensionDisabledGlobalError : public GlobalErrorWithStandardBubble,
                                      public content::NotificationObserver,
                                      public ExtensionUninstallDialog::Delegate {
  public:
   ExtensionDisabledGlobalError(ExtensionService* service,
                                const Extension* extension,
+                               bool is_remote_install,
                                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_;
+  bool is_remote_install_;
   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,
+    bool is_remote_install,
     const gfx::Image& icon)
     : service_(service),
       extension_(extension),
+      is_remote_install_(is_remote_install),
       icon_(icon),
       user_response_(IGNORED),
       menu_command_id_(GetMenuCommandID()) {
   if (icon_.IsEmpty()) {
     icon_ = gfx::Image(
         gfx::ImageSkiaOperations::CreateResizedImage(
             extension_->is_app() ?
                 extensions::util::GetDefaultAppIcon() :
                 extensions::util::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 (is_remote_install_) {
+    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 (is_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 (is_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 (is_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(
+        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 (is_remote_install_) {
+    return l10n_util::GetStringUTF16(
+        IDS_EXTENSION_PROMPT_REMOTE_INSTALL_BUTTON);
+  } else {
+    return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON);

[meacer, 2014/05/15 00:01:10]

nit: might want to use

return is_remote_install_ ? IDS_EXTENSION_PROMPT_REMOTE_INSTALL_BUTTON :
                                         IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON;

instead to avoid a possible "not all paths return value" error during compile.

+  }
 }
 
 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,
+                                       bool is_remote_install,
                                        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, is_remote_install, icon));
   }
 }
 
 void AddExtensionDisabledError(ExtensionService* service,
-                               const Extension* extension) {
+                               const Extension* extension,
+                               bool is_remote_install) {
   // 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(),
+                                  is_remote_install));
 }
 
 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