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 } 904
