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