src/chrome/browser/extensions/extension_install_prompt.cc

   1 // Copyright (c) 2012 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_install_prompt.h"
   6
   7 #include <map>
   8
   9 #include "base/command_line.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/strings/string_number_conversions.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/stringprintf.h"
  15 #include "base/strings/utf_string_conversions.h"
  16 #include "chrome/browser/extensions/bundle_installer.h"
  17 #include "chrome/browser/extensions/extension_install_ui.h"
  18 #include "chrome/browser/extensions/extension_util.h"
  19 #include "chrome/browser/extensions/permissions_updater.h"
  20 #include "chrome/browser/profiles/profile.h"
  21 #include "chrome/browser/ui/browser.h"
  22 #include "chrome/browser/ui/browser_window.h"
  23 #include "chrome/common/chrome_switches.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "chrome/grit/chromium_strings.h"
  26 #include "chrome/grit/generated_resources.h"
  27 #include "content/public/browser/web_contents.h"
  28 #include "extensions/browser/extension_prefs.h"
  29 #include "extensions/browser/extension_util.h"
  30 #include "extensions/browser/image_loader.h"
  31 #include "extensions/common/constants.h"
  32 #include "extensions/common/extension.h"
  33 #include "extensions/common/extension_icon_set.h"
  34 #include "extensions/common/extension_resource.h"
  35 #include "extensions/common/feature_switch.h"
  36 #include "extensions/common/manifest.h"
  37 #include "extensions/common/manifest_constants.h"
  38 #include "extensions/common/manifest_handlers/icons_handler.h"
  39 #include "extensions/common/permissions/permission_message_provider.h"
  40 #include "extensions/common/permissions/permission_set.h"
  41 #include "extensions/common/permissions/permissions_data.h"
  42 #include "extensions/common/url_pattern.h"
  43 #include "grit/theme_resources.h"
  44 #include "ui/base/l10n/l10n_util.h"
  45 #include "ui/base/resource/resource_bundle.h"
  46 #include "ui/gfx/image/image.h"
  47
  48 using extensions::BundleInstaller;
  49 using extensions::Extension;
  50 using extensions::Manifest;
  51 using extensions::PermissionSet;
  52
  53 namespace {
  54
  55 bool AllowWebstoreData(ExtensionInstallPrompt::PromptType type) {
  56   return type == ExtensionInstallPrompt::INLINE_INSTALL_PROMPT ||
  57          type == ExtensionInstallPrompt::EXTERNAL_INSTALL_PROMPT ||
  58          type == ExtensionInstallPrompt::REPAIR_PROMPT;
  59 }
  60
  61 static const int kTitleIds[ExtensionInstallPrompt::NUM_PROMPT_TYPES] = {
  62     0,  // The regular install prompt depends on what's being installed.
  63     IDS_EXTENSION_INLINE_INSTALL_PROMPT_TITLE,
  64     IDS_EXTENSION_INSTALL_PROMPT_TITLE,
  65     IDS_EXTENSION_RE_ENABLE_PROMPT_TITLE,
  66     IDS_EXTENSION_PERMISSIONS_PROMPT_TITLE,
  67     IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_TITLE,
  68     IDS_EXTENSION_POST_INSTALL_PERMISSIONS_PROMPT_TITLE,
  69     IDS_EXTENSION_LAUNCH_APP_PROMPT_TITLE,
  70     0,  // The remote install prompt depends on what's being installed.
  71     0,  // The repair install prompt depends on what's being installed.
  72 };
  73 static const int kHeadingIds[ExtensionInstallPrompt::NUM_PROMPT_TYPES] = {
  74     IDS_EXTENSION_INSTALL_PROMPT_HEADING,
  75     0,  // Inline installs use the extension name.
  76     0,  // Heading for bundle installs depends on the bundle contents.
  77     IDS_EXTENSION_RE_ENABLE_PROMPT_HEADING,
  78     IDS_EXTENSION_PERMISSIONS_PROMPT_HEADING,
  79     0,  // External installs use different strings for extensions/apps.
  80     IDS_EXTENSION_POST_INSTALL_PERMISSIONS_PROMPT_HEADING,
  81     IDS_EXTENSION_LAUNCH_APP_PROMPT_HEADING,
  82     IDS_EXTENSION_REMOTE_INSTALL_PROMPT_HEADING,
  83     IDS_EXTENSION_REPAIR_PROMPT_HEADING
  84 };
  85 static const int kButtons[ExtensionInstallPrompt::NUM_PROMPT_TYPES] = {
  86     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  87     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  88     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  89     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  90     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  91     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  92     ui::DIALOG_BUTTON_CANCEL,
  93     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  94     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  95     ui::DIALOG_BUTTON_OK | ui::DIALOG_BUTTON_CANCEL,
  96 };
  97 static const int kAcceptButtonIds[ExtensionInstallPrompt::NUM_PROMPT_TYPES] = {
  98     IDS_EXTENSION_PROMPT_INSTALL_BUTTON,
  99     IDS_EXTENSION_PROMPT_INSTALL_BUTTON,
 100     IDS_EXTENSION_PROMPT_INSTALL_BUTTON,
 101     IDS_EXTENSION_PROMPT_RE_ENABLE_BUTTON,
 102     IDS_EXTENSION_PROMPT_PERMISSIONS_BUTTON,
 103     0,  // External installs use different strings for extensions/apps.
 104     IDS_EXTENSION_PROMPT_PERMISSIONS_CLEAR_RETAINED_FILES_BUTTON,
 105     IDS_EXTENSION_PROMPT_LAUNCH_BUTTON,
 106     IDS_EXTENSION_PROMPT_REMOTE_INSTALL_BUTTON,
 107     IDS_EXTENSION_PROMPT_REPAIR_BUTTON,
 108 };
 109 static const int kAbortButtonIds[ExtensionInstallPrompt::NUM_PROMPT_TYPES] = {
 110     0,  // These all use the platform's default cancel label.
 111     0,
 112     0,
 113     0,
 114     IDS_EXTENSION_PROMPT_PERMISSIONS_ABORT_BUTTON,
 115     IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_ABORT_BUTTON,
 116     IDS_CLOSE,
 117     0,  // Platform dependent cancel button.
 118     0,
 119     0,
 120 };
 121 static const int
 122     kPermissionsHeaderIds[ExtensionInstallPrompt::NUM_PROMPT_TYPES] = {
 123         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
 124         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
 125         IDS_EXTENSION_PROMPT_THESE_WILL_HAVE_ACCESS_TO,
 126         IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO,
 127         IDS_EXTENSION_PROMPT_WANTS_ACCESS_TO,
 128         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
 129         IDS_EXTENSION_PROMPT_CAN_ACCESS,
 130         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
 131         IDS_EXTENSION_PROMPT_WILL_HAVE_ACCESS_TO,
 132         IDS_EXTENSION_PROMPT_CAN_ACCESS,
 133 };
 134
 135 // Returns bitmap for the default icon with size equal to the default icon's
 136 // pixel size under maximal supported scale factor.
 137 SkBitmap GetDefaultIconBitmapForMaxScaleFactor(bool is_app) {
 138   const gfx::ImageSkia& image = is_app ?
 139       extensions::util::GetDefaultAppIcon() :
 140       extensions::util::GetDefaultExtensionIcon();
 141   return image.GetRepresentation(
 142       gfx::ImageSkia::GetMaxSupportedScale()).sk_bitmap();
 143 }
 144
 145 // If auto confirm is enabled then posts a task to proceed with or cancel the
 146 // install and returns true. Otherwise returns false.
 147 bool AutoConfirmPrompt(ExtensionInstallPrompt::Delegate* delegate) {
 148   switch (ExtensionInstallPrompt::g_auto_confirm_for_tests) {
 149     case ExtensionInstallPrompt::NONE:
 150       return false;
 151     // We use PostTask instead of calling the delegate directly here, because in
 152     // the real implementations it's highly likely the message loop will be
 153     // pumping a few times before the user clicks accept or cancel.
 154     case ExtensionInstallPrompt::ACCEPT:
 155       base::MessageLoop::current()->PostTask(
 156           FROM_HERE,
 157           base::Bind(&ExtensionInstallPrompt::Delegate::InstallUIProceed,
 158                      base::Unretained(delegate)));
 159       return true;
 160     case ExtensionInstallPrompt::CANCEL:
 161       base::MessageLoop::current()->PostTask(
 162           FROM_HERE,
 163           base::Bind(&ExtensionInstallPrompt::Delegate::InstallUIAbort,
 164                      base::Unretained(delegate),
 165                      true));
 166       return true;
 167   }
 168
 169   NOTREACHED();
 170   return false;
 171 }
 172
 173 Profile* ProfileForWebContents(content::WebContents* web_contents) {
 174   if (!web_contents)
 175     return NULL;
 176   return Profile::FromBrowserContext(web_contents->GetBrowserContext());
 177 }
 178
 179 gfx::NativeWindow NativeWindowForWebContents(content::WebContents* contents) {
 180   if (!contents)
 181     return NULL;
 182
 183   return contents->GetTopLevelNativeWindow();
 184 }
 185
 186 }  // namespace
 187
 188 ExtensionInstallPrompt::Prompt::InstallPromptPermissions::
 189     InstallPromptPermissions() {
 190 }
 191 ExtensionInstallPrompt::Prompt::InstallPromptPermissions::
 192     ~InstallPromptPermissions() {
 193 }
 194
 195 // static
 196 ExtensionInstallPrompt::AutoConfirmForTests
 197 ExtensionInstallPrompt::g_auto_confirm_for_tests = ExtensionInstallPrompt::NONE;
 198
 199 // This should match the PromptType enum.
 200 std::string ExtensionInstallPrompt::PromptTypeToString(PromptType type) {
 201   switch (type) {
 202     case ExtensionInstallPrompt::INSTALL_PROMPT:
 203       return "INSTALL_PROMPT";
 204     case ExtensionInstallPrompt::INLINE_INSTALL_PROMPT:
 205       return "INLINE_INSTALL_PROMPT";
 206     case ExtensionInstallPrompt::BUNDLE_INSTALL_PROMPT:
 207       return "BUNDLE_INSTALL_PROMPT";
 208     case ExtensionInstallPrompt::RE_ENABLE_PROMPT:
 209       return "RE_ENABLE_PROMPT";
 210     case ExtensionInstallPrompt::PERMISSIONS_PROMPT:
 211       return "PERMISSIONS_PROMPT";
 212     case ExtensionInstallPrompt::EXTERNAL_INSTALL_PROMPT:
 213       return "EXTERNAL_INSTALL_PROMPT";
 214     case ExtensionInstallPrompt::POST_INSTALL_PERMISSIONS_PROMPT:
 215       return "POST_INSTALL_PERMISSIONS_PROMPT";
 216     case ExtensionInstallPrompt::LAUNCH_PROMPT:
 217       return "LAUNCH_PROMPT";
 218     case ExtensionInstallPrompt::REMOTE_INSTALL_PROMPT:
 219       return "REMOTE_INSTALL_PROMPT";
 220     case ExtensionInstallPrompt::REPAIR_PROMPT:
 221       return "REPAIR_PROMPT";
 222     case ExtensionInstallPrompt::UNSET_PROMPT_TYPE:
 223     case ExtensionInstallPrompt::NUM_PROMPT_TYPES:
 224       break;
 225   }
 226   return "OTHER";
 227 }
 228
 229 ExtensionInstallPrompt::Prompt::Prompt(PromptType type)
 230     : type_(type),
 231       is_showing_details_for_retained_files_(false),
 232       extension_(NULL),
 233       bundle_(NULL),
 234       average_rating_(0.0),
 235       rating_count_(0),
 236       show_user_count_(false),
 237       has_webstore_data_(false) {
 238 }
 239
 240 ExtensionInstallPrompt::Prompt::~Prompt() {
 241 }
 242
 243 void ExtensionInstallPrompt::Prompt::SetPermissions(
 244     const std::vector<base::string16>& permissions,
 245     PermissionsType permissions_type) {
 246   GetPermissionsForType(permissions_type).permissions = permissions;
 247 }
 248
 249 void ExtensionInstallPrompt::Prompt::SetPermissionsDetails(
 250     const std::vector<base::string16>& details,
 251     PermissionsType permissions_type) {
 252   InstallPromptPermissions& install_permissions =
 253       GetPermissionsForType(permissions_type);
 254   install_permissions.details = details;
 255   install_permissions.is_showing_details.clear();
 256   install_permissions.is_showing_details.insert(
 257       install_permissions.is_showing_details.begin(), details.size(), false);
 258 }
 259
 260 void ExtensionInstallPrompt::Prompt::SetIsShowingDetails(
 261     DetailsType type,
 262     size_t index,
 263     bool is_showing_details) {
 264   switch (type) {
 265     case PERMISSIONS_DETAILS:
 266       prompt_permissions_.is_showing_details[index] = is_showing_details;
 267       break;
 268     case WITHHELD_PERMISSIONS_DETAILS:
 269       withheld_prompt_permissions_.is_showing_details[index] =
 270           is_showing_details;
 271       break;
 272     case RETAINED_FILES_DETAILS:
 273       is_showing_details_for_retained_files_ = is_showing_details;
 274       break;
 275   }
 276 }
 277
 278 void ExtensionInstallPrompt::Prompt::SetWebstoreData(
 279     const std::string& localized_user_count,
 280     bool show_user_count,
 281     double average_rating,
 282     int rating_count) {
 283   CHECK(AllowWebstoreData(type_));
 284   localized_user_count_ = localized_user_count;
 285   show_user_count_ = show_user_count;
 286   average_rating_ = average_rating;
 287   rating_count_ = rating_count;
 288   has_webstore_data_ = true;
 289 }
 290
 291 base::string16 ExtensionInstallPrompt::Prompt::GetDialogTitle() const {
 292   int resource_id = kTitleIds[type_];
 293
 294   if (type_ == INSTALL_PROMPT) {
 295     if (extension_->is_app())
 296       resource_id = IDS_EXTENSION_INSTALL_APP_PROMPT_TITLE;
 297     else if (extension_->is_theme())
 298       resource_id = IDS_EXTENSION_INSTALL_THEME_PROMPT_TITLE;
 299     else
 300       resource_id = IDS_EXTENSION_INSTALL_EXTENSION_PROMPT_TITLE;
 301   } else if (type_ == EXTERNAL_INSTALL_PROMPT) {
 302     return l10n_util::GetStringFUTF16(
 303         resource_id, base::UTF8ToUTF16(extension_->name()));
 304   } else if (type_ == REMOTE_INSTALL_PROMPT) {
 305     if (extension_->is_app())
 306       resource_id = IDS_EXTENSION_REMOTE_INSTALL_APP_PROMPT_TITLE;
 307     else
 308       resource_id = IDS_EXTENSION_REMOTE_INSTALL_EXTENSION_PROMPT_TITLE;
 309   } else if (type_ == REPAIR_PROMPT) {
 310     if (extension_->is_app())
 311       resource_id = IDS_EXTENSION_REPAIR_APP_PROMPT_TITLE;
 312     else
 313       resource_id = IDS_EXTENSION_REPAIR_EXTENSION_PROMPT_TITLE;
 314   }
 315
 316   return l10n_util::GetStringUTF16(resource_id);
 317 }
 318
 319 base::string16 ExtensionInstallPrompt::Prompt::GetHeading() const {
 320   if (type_ == INLINE_INSTALL_PROMPT) {
 321     return base::UTF8ToUTF16(extension_->name());
 322   } else if (type_ == BUNDLE_INSTALL_PROMPT) {
 323     return bundle_->GetHeadingTextFor(BundleInstaller::Item::STATE_PENDING);
 324   } else if (type_ == EXTERNAL_INSTALL_PROMPT) {
 325     int resource_id = -1;
 326     if (extension_->is_app())
 327       resource_id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_HEADING_APP;
 328     else if (extension_->is_theme())
 329       resource_id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_HEADING_THEME;
 330     else
 331       resource_id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_HEADING_EXTENSION;
 332     return l10n_util::GetStringUTF16(resource_id);
 333   } else {
 334     return l10n_util::GetStringFUTF16(
 335         kHeadingIds[type_], base::UTF8ToUTF16(extension_->name()));
 336   }
 337 }
 338
 339 int ExtensionInstallPrompt::Prompt::GetDialogButtons() const {
 340   if (type_ == POST_INSTALL_PERMISSIONS_PROMPT &&
 341       ShouldDisplayRevokeFilesButton()) {
 342     return kButtons[type_] | ui::DIALOG_BUTTON_OK;
 343   }
 344
 345   return kButtons[type_];
 346 }
 347
 348 bool ExtensionInstallPrompt::Prompt::ShouldShowExplanationText() const {
 349   return type_ == INSTALL_PROMPT && extension_->is_extension() &&
 350          experiment_.get() && experiment_->text_only();
 351 }
 352
 353 bool ExtensionInstallPrompt::Prompt::HasAcceptButtonLabel() const {
 354   if (kAcceptButtonIds[type_] == 0)
 355     return false;
 356
 357   if (type_ == POST_INSTALL_PERMISSIONS_PROMPT)
 358     return ShouldDisplayRevokeFilesButton();
 359
 360   return true;
 361 }
 362
 363 base::string16 ExtensionInstallPrompt::Prompt::GetAcceptButtonLabel() const {
 364   if (type_ == EXTERNAL_INSTALL_PROMPT) {
 365     int id = -1;
 366     if (extension_->is_app())
 367       id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_ACCEPT_BUTTON_APP;
 368     else if (extension_->is_theme())
 369       id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_ACCEPT_BUTTON_THEME;
 370     else
 371       id = IDS_EXTENSION_EXTERNAL_INSTALL_PROMPT_ACCEPT_BUTTON_EXTENSION;
 372     return l10n_util::GetStringUTF16(id);
 373   }
 374   if (ShouldShowExplanationText())
 375     return experiment_->GetOkButtonText();
 376   return l10n_util::GetStringUTF16(kAcceptButtonIds[type_]);
 377 }
 378
 379 bool ExtensionInstallPrompt::Prompt::HasAbortButtonLabel() const {
 380   if (ShouldShowExplanationText())
 381     return true;
 382   return kAbortButtonIds[type_] > 0;
 383 }
 384
 385 base::string16 ExtensionInstallPrompt::Prompt::GetAbortButtonLabel() const {
 386   CHECK(HasAbortButtonLabel());
 387   if (ShouldShowExplanationText())
 388     return experiment_->GetCancelButtonText();
 389   return l10n_util::GetStringUTF16(kAbortButtonIds[type_]);
 390 }
 391
 392 base::string16 ExtensionInstallPrompt::Prompt::GetPermissionsHeading(
 393     PermissionsType permissions_type) const {
 394   switch (permissions_type) {
 395     case REGULAR_PERMISSIONS:
 396       return l10n_util::GetStringUTF16(kPermissionsHeaderIds[type_]);
 397     case WITHHELD_PERMISSIONS:
 398       return l10n_util::GetStringUTF16(IDS_EXTENSION_PROMPT_WITHHELD);
 399     case ALL_PERMISSIONS:
 400     default:
 401       NOTREACHED();
 402       return base::string16();
 403   }
 404 }
 405
 406 base::string16 ExtensionInstallPrompt::Prompt::GetRetainedFilesHeading() const {
 407   const int kRetainedFilesMessageIDs[6] = {
 408       IDS_EXTENSION_PROMPT_RETAINED_FILES_DEFAULT,
 409       IDS_EXTENSION_PROMPT_RETAINED_FILE_SINGULAR,
 410       IDS_EXTENSION_PROMPT_RETAINED_FILES_ZERO,
 411       IDS_EXTENSION_PROMPT_RETAINED_FILES_TWO,
 412       IDS_EXTENSION_PROMPT_RETAINED_FILES_FEW,
 413       IDS_EXTENSION_PROMPT_RETAINED_FILES_MANY,
 414   };
 415   std::vector<int> message_ids;
 416   for (size_t i = 0; i < arraysize(kRetainedFilesMessageIDs); i++) {
 417     message_ids.push_back(kRetainedFilesMessageIDs[i]);
 418   }
 419   return l10n_util::GetPluralStringFUTF16(message_ids, GetRetainedFileCount());
 420 }
 421
 422 bool ExtensionInstallPrompt::Prompt::ShouldShowPermissions() const {
 423   return GetPermissionCount(ALL_PERMISSIONS) > 0 ||
 424          type_ == POST_INSTALL_PERMISSIONS_PROMPT;
 425 }
 426
 427 void ExtensionInstallPrompt::Prompt::AppendRatingStars(
 428     StarAppender appender, void* data) const {
 429   CHECK(appender);
 430   CHECK(AllowWebstoreData(type_));
 431   int rating_integer = floor(average_rating_);
 432   double rating_fractional = average_rating_ - rating_integer;
 433
 434   if (rating_fractional > 0.66) {
 435     rating_integer++;
 436   }
 437
 438   if (rating_fractional < 0.33 || rating_fractional > 0.66) {
 439     rating_fractional = 0;
 440   }
 441
 442   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
 443   int i;
 444   for (i = 0; i < rating_integer; i++) {
 445     appender(rb.GetImageSkiaNamed(IDR_EXTENSIONS_RATING_STAR_ON), data);
 446   }
 447   if (rating_fractional) {
 448     appender(rb.GetImageSkiaNamed(IDR_EXTENSIONS_RATING_STAR_HALF_LEFT), data);
 449     i++;
 450   }
 451   for (; i < kMaxExtensionRating; i++) {
 452     appender(rb.GetImageSkiaNamed(IDR_EXTENSIONS_RATING_STAR_OFF), data);
 453   }
 454 }
 455
 456 base::string16 ExtensionInstallPrompt::Prompt::GetRatingCount() const {
 457   CHECK(AllowWebstoreData(type_));
 458   return l10n_util::GetStringFUTF16(IDS_EXTENSION_RATING_COUNT,
 459                                     base::IntToString16(rating_count_));
 460 }
 461
 462 base::string16 ExtensionInstallPrompt::Prompt::GetUserCount() const {
 463   CHECK(AllowWebstoreData(type_));
 464
 465   if (show_user_count_) {
 466     return l10n_util::GetStringFUTF16(IDS_EXTENSION_USER_COUNT,
 467                                       base::UTF8ToUTF16(localized_user_count_));
 468   }
 469   return base::string16();
 470 }
 471
 472 size_t ExtensionInstallPrompt::Prompt::GetPermissionCount(
 473     PermissionsType permissions_type) const {
 474   switch (permissions_type) {
 475     case REGULAR_PERMISSIONS:
 476       return prompt_permissions_.permissions.size();
 477     case WITHHELD_PERMISSIONS:
 478       return withheld_prompt_permissions_.permissions.size();
 479     case ALL_PERMISSIONS:
 480       return prompt_permissions_.permissions.size() +
 481              withheld_prompt_permissions_.permissions.size();
 482     default:
 483       NOTREACHED();
 484       return 0u;
 485   }
 486 }
 487
 488 size_t ExtensionInstallPrompt::Prompt::GetPermissionsDetailsCount(
 489     PermissionsType permissions_type) const {
 490   switch (permissions_type) {
 491     case REGULAR_PERMISSIONS:
 492       return prompt_permissions_.details.size();
 493     case WITHHELD_PERMISSIONS:
 494       return withheld_prompt_permissions_.details.size();
 495     case ALL_PERMISSIONS:
 496       return prompt_permissions_.details.size() +
 497              withheld_prompt_permissions_.details.size();
 498     default:
 499       NOTREACHED();
 500       return 0u;
 501   }
 502 }
 503
 504 base::string16 ExtensionInstallPrompt::Prompt::GetPermission(
 505     size_t index,
 506     PermissionsType permissions_type) const {
 507   const InstallPromptPermissions& install_permissions =
 508       GetPermissionsForType(permissions_type);
 509   CHECK_LT(index, install_permissions.permissions.size());
 510   return install_permissions.permissions[index];
 511 }
 512
 513 base::string16 ExtensionInstallPrompt::Prompt::GetPermissionsDetails(
 514     size_t index,
 515     PermissionsType permissions_type) const {
 516   const InstallPromptPermissions& install_permissions =
 517       GetPermissionsForType(permissions_type);
 518   CHECK_LT(index, install_permissions.details.size());
 519   return install_permissions.details[index];
 520 }
 521
 522 bool ExtensionInstallPrompt::Prompt::GetIsShowingDetails(
 523     DetailsType type, size_t index) const {
 524   switch (type) {
 525     case PERMISSIONS_DETAILS:
 526       CHECK_LT(index, prompt_permissions_.is_showing_details.size());
 527       return prompt_permissions_.is_showing_details[index];
 528     case WITHHELD_PERMISSIONS_DETAILS:
 529       CHECK_LT(index, withheld_prompt_permissions_.is_showing_details.size());
 530       return withheld_prompt_permissions_.is_showing_details[index];
 531     case RETAINED_FILES_DETAILS:
 532       return is_showing_details_for_retained_files_;
 533   }
 534   return false;
 535 }
 536
 537 size_t ExtensionInstallPrompt::Prompt::GetRetainedFileCount() const {
 538   return retained_files_.size();
 539 }
 540
 541 base::string16 ExtensionInstallPrompt::Prompt::GetRetainedFile(size_t index)
 542     const {
 543   CHECK_LT(index, retained_files_.size());
 544   return retained_files_[index].AsUTF16Unsafe();
 545 }
 546
 547 ExtensionInstallPrompt::Prompt::InstallPromptPermissions&
 548 ExtensionInstallPrompt::Prompt::GetPermissionsForType(
 549     PermissionsType permissions_type) {
 550   DCHECK_NE(ALL_PERMISSIONS, permissions_type);
 551   return permissions_type == REGULAR_PERMISSIONS ? prompt_permissions_
 552                                                  : withheld_prompt_permissions_;
 553 }
 554
 555 const ExtensionInstallPrompt::Prompt::InstallPromptPermissions&
 556 ExtensionInstallPrompt::Prompt::GetPermissionsForType(
 557     PermissionsType permissions_type) const {
 558   DCHECK_NE(ALL_PERMISSIONS, permissions_type);
 559   return permissions_type == REGULAR_PERMISSIONS ? prompt_permissions_
 560                                                  : withheld_prompt_permissions_;
 561 }
 562
 563 bool ExtensionInstallPrompt::Prompt::ShouldDisplayRevokeFilesButton() const {
 564   return !retained_files_.empty();
 565 }
 566
 567 ExtensionInstallPrompt::ShowParams::ShowParams(content::WebContents* contents)
 568     : parent_web_contents(contents),
 569       parent_window(NativeWindowForWebContents(contents)),
 570       navigator(contents) {
 571 }
 572
 573 ExtensionInstallPrompt::ShowParams::ShowParams(
 574     gfx::NativeWindow window,
 575     content::PageNavigator* navigator)
 576     : parent_web_contents(NULL),
 577       parent_window(window),
 578       navigator(navigator) {
 579 }
 580
 581 // static
 582 scoped_refptr<Extension>
 583     ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
 584     const base::DictionaryValue* manifest,
 585     int flags,
 586     const std::string& id,
 587     const std::string& localized_name,
 588     const std::string& localized_description,
 589     std::string* error) {
 590   scoped_ptr<base::DictionaryValue> localized_manifest;
 591   if (!localized_name.empty() || !localized_description.empty()) {
 592     localized_manifest.reset(manifest->DeepCopy());
 593     if (!localized_name.empty()) {
 594       localized_manifest->SetString(extensions::manifest_keys::kName,
 595                                     localized_name);
 596     }
 597     if (!localized_description.empty()) {
 598       localized_manifest->SetString(extensions::manifest_keys::kDescription,
 599                                     localized_description);
 600     }
 601   }
 602
 603   return Extension::Create(
 604       base::FilePath(),
 605       Manifest::INTERNAL,
 606       localized_manifest.get() ? *localized_manifest.get() : *manifest,
 607       flags,
 608       id,
 609       error);
 610 }
 611
 612 ExtensionInstallPrompt::ExtensionInstallPrompt(content::WebContents* contents)
 613     : ui_loop_(base::MessageLoop::current()),
 614       extension_(NULL),
 615       bundle_(NULL),
 616       install_ui_(ExtensionInstallUI::Create(ProfileForWebContents(contents))),
 617       show_params_(contents),
 618       delegate_(NULL) {
 619 }
 620
 621 ExtensionInstallPrompt::ExtensionInstallPrompt(
 622     Profile* profile,
 623     gfx::NativeWindow native_window,
 624     content::PageNavigator* navigator)
 625     : ui_loop_(base::MessageLoop::current()),
 626       extension_(NULL),
 627       bundle_(NULL),
 628       install_ui_(ExtensionInstallUI::Create(profile)),
 629       show_params_(native_window, navigator),
 630       delegate_(NULL) {
 631 }
 632
 633 ExtensionInstallPrompt::~ExtensionInstallPrompt() {
 634 }
 635
 636 void ExtensionInstallPrompt::ConfirmBundleInstall(
 637     extensions::BundleInstaller* bundle,
 638     const PermissionSet* permissions) {
 639   DCHECK(ui_loop_ == base::MessageLoop::current());
 640   bundle_ = bundle;
 641   custom_permissions_ = permissions;
 642   delegate_ = bundle;
 643   prompt_ = new Prompt(BUNDLE_INSTALL_PROMPT);
 644
 645   ShowConfirmation();
 646 }
 647
 648 void ExtensionInstallPrompt::ConfirmStandaloneInstall(
 649     Delegate* delegate,
 650     const Extension* extension,
 651     SkBitmap* icon,
 652     scoped_refptr<Prompt> prompt) {
 653   DCHECK(ui_loop_ == base::MessageLoop::current());
 654   extension_ = extension;
 655   delegate_ = delegate;
 656   prompt_ = prompt;
 657
 658   SetIcon(icon);
 659   ShowConfirmation();
 660 }
 661
 662 void ExtensionInstallPrompt::ConfirmWebstoreInstall(
 663     Delegate* delegate,
 664     const Extension* extension,
 665     const SkBitmap* icon,
 666     const ShowDialogCallback& show_dialog_callback) {
 667   // SetIcon requires |extension_| to be set. ConfirmInstall will setup the
 668   // remaining fields.
 669   extension_ = extension;
 670   SetIcon(icon);
 671   ConfirmInstall(delegate, extension, show_dialog_callback);
 672 }
 673
 674 void ExtensionInstallPrompt::ConfirmInstall(
 675     Delegate* delegate,
 676     const Extension* extension,
 677     const ShowDialogCallback& show_dialog_callback) {
 678   DCHECK(ui_loop_ == base::MessageLoop::current());
 679   extension_ = extension;
 680   delegate_ = delegate;
 681   prompt_ = new Prompt(INSTALL_PROMPT);
 682   show_dialog_callback_ = show_dialog_callback;
 683
 684   // We special-case themes to not show any confirm UI. Instead they are
 685   // immediately installed, and then we show an infobar (see OnInstallSuccess)
 686   // to allow the user to revert if they don't like it.
 687   //
 688   // We don't do this in the case where off-store extension installs are
 689   // disabled because in that case, we don't show the dangerous download UI, so
 690   // we need the UI confirmation.
 691   if (extension->is_theme()) {
 692     if (extension->from_webstore() ||
 693         extensions::FeatureSwitch::easy_off_store_install()->IsEnabled()) {
 694       delegate->InstallUIProceed();
 695       return;
 696     }
 697   }
 698
 699   LoadImageIfNeeded();
 700 }
 701
 702 void ExtensionInstallPrompt::ConfirmReEnable(Delegate* delegate,
 703                                              const Extension* extension) {
 704   DCHECK(ui_loop_ == base::MessageLoop::current());
 705   extension_ = extension;
 706   delegate_ = delegate;
 707   bool is_remote_install =
 708       install_ui_->profile() &&
 709       extensions::ExtensionPrefs::Get(install_ui_->profile())->HasDisableReason(
 710           extension->id(), extensions::Extension::DISABLE_REMOTE_INSTALL);
 711   bool is_ephemeral =
 712       extensions::util::IsEphemeralApp(extension->id(), install_ui_->profile());
 713
 714   PromptType type = UNSET_PROMPT_TYPE;
 715   if (is_ephemeral)
 716     type = LAUNCH_PROMPT;
 717   else if (is_remote_install)
 718     type = REMOTE_INSTALL_PROMPT;
 719   else
 720     type = RE_ENABLE_PROMPT;
 721   prompt_ = new Prompt(type);
 722
 723   LoadImageIfNeeded();
 724 }
 725
 726 void ExtensionInstallPrompt::ConfirmExternalInstall(
 727     Delegate* delegate,
 728     const Extension* extension,
 729     const ShowDialogCallback& show_dialog_callback,
 730     scoped_refptr<Prompt> prompt) {
 731   DCHECK(ui_loop_ == base::MessageLoop::current());
 732   extension_ = extension;
 733   delegate_ = delegate;
 734   prompt_ = prompt;
 735   show_dialog_callback_ = show_dialog_callback;
 736
 737   LoadImageIfNeeded();
 738 }
 739
 740 void ExtensionInstallPrompt::ConfirmPermissions(
 741     Delegate* delegate,
 742     const Extension* extension,
 743     const PermissionSet* permissions) {
 744   DCHECK(ui_loop_ == base::MessageLoop::current());
 745   extension_ = extension;
 746   custom_permissions_ = permissions;
 747   delegate_ = delegate;
 748   prompt_ = new Prompt(PERMISSIONS_PROMPT);
 749
 750   LoadImageIfNeeded();
 751 }
 752
 753 void ExtensionInstallPrompt::ReviewPermissions(
 754     Delegate* delegate,
 755     const Extension* extension,
 756     const std::vector<base::FilePath>& retained_file_paths) {
 757   DCHECK(ui_loop_ == base::MessageLoop::current());
 758   extension_ = extension;
 759   prompt_ = new Prompt(POST_INSTALL_PERMISSIONS_PROMPT);
 760   prompt_->set_retained_files(retained_file_paths);
 761   delegate_ = delegate;
 762
 763   LoadImageIfNeeded();
 764 }
 765
 766 void ExtensionInstallPrompt::OnInstallSuccess(const Extension* extension,
 767                                               SkBitmap* icon) {
 768   extension_ = extension;
 769   SetIcon(icon);
 770
 771   install_ui_->OnInstallSuccess(extension, &icon_);
 772 }
 773
 774 void ExtensionInstallPrompt::OnInstallFailure(
 775     const extensions::CrxInstallerError& error) {
 776   install_ui_->OnInstallFailure(error);
 777 }
 778
 779 void ExtensionInstallPrompt::SetIcon(const SkBitmap* image) {
 780   if (image)
 781     icon_ = *image;
 782   else
 783     icon_ = SkBitmap();
 784   if (icon_.empty()) {
 785     // Let's set default icon bitmap whose size is equal to the default icon's
 786     // pixel size under maximal supported scale factor. If the bitmap is larger
 787     // than the one we need, it will be scaled down by the ui code.
 788     icon_ = GetDefaultIconBitmapForMaxScaleFactor(extension_->is_app());
 789   }
 790 }
 791
 792 void ExtensionInstallPrompt::OnImageLoaded(const gfx::Image& image) {
 793   SetIcon(image.IsEmpty() ? NULL : image.ToSkBitmap());
 794   ShowConfirmation();
 795 }
 796
 797 void ExtensionInstallPrompt::LoadImageIfNeeded() {
 798   // Bundle install prompts do not have an icon.
 799   // Also |install_ui_.profile()| can be NULL in unit tests.
 800   if (!icon_.empty() || !install_ui_->profile()) {
 801     ShowConfirmation();
 802     return;
 803   }
 804
 805   extensions::ExtensionResource image = extensions::IconsInfo::GetIconResource(
 806       extension_,
 807       extension_misc::EXTENSION_ICON_LARGE,
 808       ExtensionIconSet::MATCH_BIGGER);
 809
 810   // Load the image asynchronously. The response will be sent to OnImageLoaded.
 811   extensions::ImageLoader* loader =
 812       extensions::ImageLoader::Get(install_ui_->profile());
 813
 814   std::vector<extensions::ImageLoader::ImageRepresentation> images_list;
 815   images_list.push_back(extensions::ImageLoader::ImageRepresentation(
 816       image,
 817       extensions::ImageLoader::ImageRepresentation::NEVER_RESIZE,
 818       gfx::Size(),
 819       ui::SCALE_FACTOR_100P));
 820   loader->LoadImagesAsync(
 821       extension_,
 822       images_list,
 823       base::Bind(&ExtensionInstallPrompt::OnImageLoaded, AsWeakPtr()));
 824 }
 825
 826 void ExtensionInstallPrompt::ShowConfirmation() {
 827   if (prompt_->type() == INSTALL_PROMPT)
 828     prompt_->set_experiment(ExtensionInstallPromptExperiment::Find());
 829   else
 830     prompt_->set_experiment(ExtensionInstallPromptExperiment::ControlGroup());
 831
 832   scoped_refptr<const PermissionSet> permissions_to_display;
 833   if (custom_permissions_.get()) {
 834     permissions_to_display = custom_permissions_;
 835   } else if (extension_) {
 836     // Initialize permissions if they have not already been set so that
 837     // withheld permissions are displayed properly in the install prompt.
 838     extensions::PermissionsUpdater(
 839         install_ui_->profile(),
 840         extensions::PermissionsUpdater::INIT_FLAG_TRANSIENT)
 841         .InitializePermissions(extension_);
 842     permissions_to_display =
 843         extension_->permissions_data()->active_permissions();
 844   }
 845
 846   if (permissions_to_display.get() &&
 847       (!extension_ ||
 848        !extensions::PermissionsData::ShouldSkipPermissionWarnings(
 849            extension_->id()))) {
 850     Manifest::Type type =
 851         extension_ ? extension_->GetType() : Manifest::TYPE_UNKNOWN;
 852     const extensions::PermissionMessageProvider* message_provider =
 853         extensions::PermissionMessageProvider::Get();
 854     prompt_->SetPermissions(message_provider->GetWarningMessages(
 855                                 permissions_to_display.get(), type),
 856                             REGULAR_PERMISSIONS);
 857     prompt_->SetPermissionsDetails(message_provider->GetWarningMessagesDetails(
 858                                        permissions_to_display.get(), type),
 859                                    REGULAR_PERMISSIONS);
 860
 861     scoped_refptr<const extensions::PermissionSet> withheld =
 862         extension_->permissions_data()->withheld_permissions();
 863     if (!withheld->IsEmpty()) {
 864       prompt_->SetPermissions(
 865           message_provider->GetWarningMessages(withheld.get(), type),
 866           PermissionsType::WITHHELD_PERMISSIONS);
 867       prompt_->SetPermissionsDetails(
 868           message_provider->GetWarningMessagesDetails(withheld.get(), type),
 869           PermissionsType::WITHHELD_PERMISSIONS);
 870     }
 871   }
 872
 873   switch (prompt_->type()) {
 874     case PERMISSIONS_PROMPT:
 875     case RE_ENABLE_PROMPT:
 876     case INLINE_INSTALL_PROMPT:
 877     case EXTERNAL_INSTALL_PROMPT:
 878     case INSTALL_PROMPT:
 879     case LAUNCH_PROMPT:
 880     case POST_INSTALL_PERMISSIONS_PROMPT:
 881     case REMOTE_INSTALL_PROMPT:
 882     case REPAIR_PROMPT: {
 883       prompt_->set_extension(extension_);
 884       prompt_->set_icon(gfx::Image::CreateFrom1xBitmap(icon_));
 885       break;
 886     }
 887     case BUNDLE_INSTALL_PROMPT: {
 888       prompt_->set_bundle(bundle_);
 889       break;
 890     }
 891     default:
 892       NOTREACHED() << "Unknown message";
 893       return;
 894   }
 895
 896   if (AutoConfirmPrompt(delegate_))
 897     return;
 898
 899   if (show_dialog_callback_.is_null())
 900     GetDefaultShowDialogCallback().Run(show_params_, delegate_, prompt_);
 901   else
 902     show_dialog_callback_.Run(show_params_, delegate_, prompt_);
 903 }