components/page_info/page_info_ui.cc

   1 // Copyright 2012 The Chromium Authors
   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 "components/page_info/page_info_ui.h"
   6
   7 #include <utility>
   8
   9 #include "base/command_line.h"
  10 #include "base/containers/span.h"
  11 #include "base/feature_list.h"
  12 #include "base/strings/utf_string_conversions.h"
  13 #include "build/build_config.h"
  14 #include "build/chromeos_buildflags.h"
  15 #include "components/omnibox/common/omnibox_features.h"
  16 #include "components/page_info/core/features.h"
  17 #include "components/page_info/page_info_ui_delegate.h"
  18 #include "components/permissions/features.h"
  19 #include "components/permissions/permission_decision_auto_blocker.h"
  20 #include "components/permissions/permission_manager.h"
  21 #include "components/permissions/permission_result.h"
  22 #include "components/permissions/permission_util.h"
  23 #include "components/prefs/pref_service.h"
  24 #include "components/safe_browsing/buildflags.h"
  25 #include "components/security_interstitials/core/common_string_util.h"
  26 #include "components/strings/grit/components_chromium_strings.h"
  27 #include "components/strings/grit/components_strings.h"
  28 #include "ppapi/buildflags/buildflags.h"
  29 #include "services/device/public/cpp/device_features.h"
  30 #include "ui/base/l10n/l10n_util.h"
  31 #include "url/gurl.h"
  32 #if BUILDFLAG(IS_ANDROID)
  33 #include "components/resources/android/theme_resources.h"
  34 #else
  35 #include "ui/gfx/color_palette.h"
  36 #include "ui/gfx/color_utils.h"
  37 #include "ui/native_theme/native_theme.h"  // nogncheck
  38 #endif
  39
  40 #if BUILDFLAG(FULL_SAFE_BROWSING)
  41 #include "components/safe_browsing/content/browser/password_protection/password_protection_service.h"
  42 #endif
  43
  44 namespace {
  45
  46 const int kInvalidResourceID = -1;
  47
  48 // The resource IDs for the strings that are displayed on the permissions
  49 // button if the permission setting is managed by policy.
  50 const int kPermissionButtonTextIDPolicyManaged[] = {
  51     kInvalidResourceID,
  52     IDS_PAGE_INFO_PERMISSION_ALLOWED_BY_POLICY,
  53     IDS_PAGE_INFO_PERMISSION_BLOCKED_BY_POLICY,
  54     IDS_PAGE_INFO_PERMISSION_ASK_BY_POLICY,
  55     kInvalidResourceID,
  56     kInvalidResourceID};
  57 static_assert(std::size(kPermissionButtonTextIDPolicyManaged) ==
  58                   CONTENT_SETTING_NUM_SETTINGS,
  59               "kPermissionButtonTextIDPolicyManaged array size is incorrect");
  60
  61 // The resource IDs for the strings that are displayed on the permissions
  62 // button if the permission setting is managed by an extension.
  63 const int kPermissionButtonTextIDExtensionManaged[] = {
  64     kInvalidResourceID,
  65     IDS_PAGE_INFO_PERMISSION_ALLOWED_BY_EXTENSION,
  66     IDS_PAGE_INFO_PERMISSION_BLOCKED_BY_EXTENSION,
  67     IDS_PAGE_INFO_PERMISSION_ASK_BY_EXTENSION,
  68     kInvalidResourceID,
  69     kInvalidResourceID};
  70 static_assert(std::size(kPermissionButtonTextIDExtensionManaged) ==
  71                   CONTENT_SETTING_NUM_SETTINGS,
  72               "kPermissionButtonTextIDExtensionManaged array size is "
  73               "incorrect");
  74
  75 // The resource IDs for the strings that are displayed on the permissions
  76 // button if the permission setting is managed by the user.
  77 const int kPermissionButtonTextIDUserManaged[] = {
  78     kInvalidResourceID,
  79     IDS_PAGE_INFO_BUTTON_TEXT_ALLOWED_BY_USER,
  80     IDS_PAGE_INFO_BUTTON_TEXT_BLOCKED_BY_USER,
  81     IDS_PAGE_INFO_BUTTON_TEXT_ASK_BY_USER,
  82     kInvalidResourceID,
  83     IDS_PAGE_INFO_BUTTON_TEXT_DETECT_IMPORTANT_CONTENT_BY_USER};
  84 static_assert(std::size(kPermissionButtonTextIDUserManaged) ==
  85                   CONTENT_SETTING_NUM_SETTINGS,
  86               "kPermissionButtonTextIDUserManaged array size is incorrect");
  87
  88 // The resource IDs for the strings that are displayed on the permissions
  89 // button if the permission setting is the global default setting.
  90 const int kPermissionButtonTextIDDefaultSetting[] = {
  91     kInvalidResourceID,
  92     IDS_PAGE_INFO_BUTTON_TEXT_ALLOWED_BY_DEFAULT,
  93     IDS_PAGE_INFO_BUTTON_TEXT_BLOCKED_BY_DEFAULT,
  94     IDS_PAGE_INFO_BUTTON_TEXT_ASK_BY_DEFAULT,
  95     kInvalidResourceID,
  96     IDS_PAGE_INFO_BUTTON_TEXT_DETECT_IMPORTANT_CONTENT_BY_DEFAULT};
  97 static_assert(std::size(kPermissionButtonTextIDDefaultSetting) ==
  98                   CONTENT_SETTING_NUM_SETTINGS,
  99               "kPermissionButtonTextIDDefaultSetting array size is incorrect");
 100
 101 #if !BUILDFLAG(IS_ANDROID)
 102 // The resource IDs for the strings that are displayed on the sound permission
 103 // button if the sound permission setting is managed by the user.
 104 const int kSoundPermissionButtonTextIDUserManaged[] = {
 105     kInvalidResourceID,
 106     IDS_PAGE_INFO_BUTTON_TEXT_ALLOWED_BY_USER,
 107     IDS_PAGE_INFO_BUTTON_TEXT_MUTED_BY_USER,
 108     kInvalidResourceID,
 109     kInvalidResourceID,
 110     kInvalidResourceID};
 111 static_assert(
 112     std::size(kSoundPermissionButtonTextIDUserManaged) ==
 113         CONTENT_SETTING_NUM_SETTINGS,
 114     "kSoundPermissionButtonTextIDUserManaged array size is incorrect");
 115
 116 // The resource IDs for the strings that are displayed on the sound permission
 117 // button if the permission setting is the global default setting and the
 118 // block autoplay preference is disabled.
 119 const int kSoundPermissionButtonTextIDDefaultSetting[] = {
 120     kInvalidResourceID,
 121     IDS_PAGE_INFO_BUTTON_TEXT_ALLOWED_BY_DEFAULT,
 122     IDS_PAGE_INFO_BUTTON_TEXT_MUTED_BY_DEFAULT,
 123     kInvalidResourceID,
 124     kInvalidResourceID,
 125     kInvalidResourceID};
 126 static_assert(
 127     std::size(kSoundPermissionButtonTextIDDefaultSetting) ==
 128         CONTENT_SETTING_NUM_SETTINGS,
 129     "kSoundPermissionButtonTextIDDefaultSetting array size is incorrect");
 130 #endif
 131
 132 base::span<const PageInfoUI::PermissionUIInfo> GetContentSettingsUIInfo() {
 133   DCHECK(base::FeatureList::GetInstance() != nullptr);
 134   static const PageInfoUI::PermissionUIInfo kPermissionUIInfo[] = {
 135     {ContentSettingsType::COOKIES, IDS_SITE_SETTINGS_TYPE_COOKIES,
 136      IDS_SITE_SETTINGS_TYPE_COOKIES_MID_SENTENCE},
 137     {ContentSettingsType::JAVASCRIPT, IDS_SITE_SETTINGS_TYPE_JAVASCRIPT,
 138      IDS_SITE_SETTINGS_TYPE_JAVASCRIPT_MID_SENTENCE},
 139     {ContentSettingsType::POPUPS, IDS_SITE_SETTINGS_TYPE_POPUPS_REDIRECTS,
 140      IDS_SITE_SETTINGS_TYPE_POPUPS_REDIRECTS_MID_SENTENCE},
 141     {ContentSettingsType::GEOLOCATION, IDS_SITE_SETTINGS_TYPE_LOCATION,
 142      IDS_SITE_SETTINGS_TYPE_LOCATION_MID_SENTENCE},
 143     {ContentSettingsType::NOTIFICATIONS, IDS_SITE_SETTINGS_TYPE_NOTIFICATIONS,
 144      IDS_SITE_SETTINGS_TYPE_NOTIFICATIONS_MID_SENTENCE},
 145     {ContentSettingsType::MEDIASTREAM_MIC, IDS_SITE_SETTINGS_TYPE_MIC,
 146      IDS_SITE_SETTINGS_TYPE_MIC_MID_SENTENCE},
 147     {ContentSettingsType::MEDIASTREAM_CAMERA, IDS_SITE_SETTINGS_TYPE_CAMERA,
 148      IDS_SITE_SETTINGS_TYPE_CAMERA_MID_SENTENCE},
 149     {ContentSettingsType::AUTOMATIC_DOWNLOADS,
 150      IDS_SITE_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
 151      IDS_SITE_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS_MID_SENTENCE},
 152     {ContentSettingsType::MIDI_SYSEX, IDS_SITE_SETTINGS_TYPE_MIDI_SYSEX,
 153      IDS_SITE_SETTINGS_TYPE_MIDI_SYSEX_MID_SENTENCE},
 154     {ContentSettingsType::BACKGROUND_SYNC,
 155      IDS_SITE_SETTINGS_TYPE_BACKGROUND_SYNC,
 156      IDS_SITE_SETTINGS_TYPE_BACKGROUND_SYNC_MID_SENTENCE},
 157 #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_CHROMEOS) || BUILDFLAG(IS_WIN)
 158     {ContentSettingsType::PROTECTED_MEDIA_IDENTIFIER,
 159      IDS_SITE_SETTINGS_TYPE_PROTECTED_MEDIA_ID,
 160      IDS_SITE_SETTINGS_TYPE_PROTECTED_MEDIA_ID_MID_SENTENCE},
 161 #endif
 162     {ContentSettingsType::ADS, IDS_SITE_SETTINGS_TYPE_ADS,
 163      IDS_SITE_SETTINGS_TYPE_ADS_MID_SENTENCE},
 164     {ContentSettingsType::SOUND, IDS_SITE_SETTINGS_TYPE_SOUND,
 165      IDS_SITE_SETTINGS_TYPE_SOUND_MID_SENTENCE},
 166     {ContentSettingsType::CLIPBOARD_READ_WRITE,
 167      IDS_SITE_SETTINGS_TYPE_CLIPBOARD,
 168      IDS_SITE_SETTINGS_TYPE_CLIPBOARD_MID_SENTENCE},
 169     {
 170         ContentSettingsType::SENSORS,
 171         base::FeatureList::IsEnabled(features::kGenericSensorExtraClasses)
 172             ? IDS_SITE_SETTINGS_TYPE_SENSORS
 173             : IDS_SITE_SETTINGS_TYPE_MOTION_SENSORS,
 174         base::FeatureList::IsEnabled(features::kGenericSensorExtraClasses)
 175             ? IDS_SITE_SETTINGS_TYPE_SENSORS_MID_SENTENCE
 176             : IDS_SITE_SETTINGS_TYPE_MOTION_SENSORS_MID_SENTENCE,
 177     },
 178     {ContentSettingsType::USB_GUARD, IDS_SITE_SETTINGS_TYPE_USB_DEVICES,
 179      IDS_SITE_SETTINGS_TYPE_USB_DEVICES_MID_SENTENCE},
 180     {ContentSettingsType::BLUETOOTH_GUARD,
 181      IDS_SITE_SETTINGS_TYPE_BLUETOOTH_DEVICES,
 182      IDS_SITE_SETTINGS_TYPE_BLUETOOTH_DEVICES_MID_SENTENCE},
 183     {ContentSettingsType::BLUETOOTH_SCANNING,
 184      IDS_SITE_SETTINGS_TYPE_BLUETOOTH_SCANNING,
 185      IDS_SITE_SETTINGS_TYPE_BLUETOOTH_SCANNING_MID_SENTENCE},
 186     {ContentSettingsType::NFC, IDS_SITE_SETTINGS_TYPE_NFC,
 187      IDS_SITE_SETTINGS_TYPE_NFC_MID_SENTENCE},
 188     {ContentSettingsType::VR, IDS_SITE_SETTINGS_TYPE_VR,
 189      IDS_SITE_SETTINGS_TYPE_VR_MID_SENTENCE},
 190     {ContentSettingsType::AR, IDS_SITE_SETTINGS_TYPE_AR,
 191      IDS_SITE_SETTINGS_TYPE_AR_MID_SENTENCE},
 192     {ContentSettingsType::CAMERA_PAN_TILT_ZOOM,
 193      IDS_SITE_SETTINGS_TYPE_CAMERA_PAN_TILT_ZOOM,
 194      IDS_SITE_SETTINGS_TYPE_CAMERA_PAN_TILT_ZOOM_MID_SENTENCE},
 195     {ContentSettingsType::FEDERATED_IDENTITY_API,
 196      IDS_SITE_SETTINGS_TYPE_FEDERATED_IDENTITY_API,
 197      IDS_SITE_SETTINGS_TYPE_FEDERATED_IDENTITY_API_MID_SENTENCE},
 198     {ContentSettingsType::IDLE_DETECTION, IDS_SITE_SETTINGS_TYPE_IDLE_DETECTION,
 199      IDS_SITE_SETTINGS_TYPE_IDLE_DETECTION_MID_SENTENCE},
 200 #if !BUILDFLAG(IS_ANDROID)
 201     // Page Info Permissions that are not defined in Android.
 202     {ContentSettingsType::FILE_SYSTEM_WRITE_GUARD,
 203      IDS_SITE_SETTINGS_TYPE_FILE_SYSTEM_ACCESS_WRITE,
 204      IDS_SITE_SETTINGS_TYPE_FILE_SYSTEM_ACCESS_WRITE_MID_SENTENCE},
 205     {ContentSettingsType::LOCAL_FONTS, IDS_SITE_SETTINGS_TYPE_FONT_ACCESS,
 206      IDS_SITE_SETTINGS_TYPE_FONT_ACCESS_MID_SENTENCE},
 207     {ContentSettingsType::HID_GUARD, IDS_SITE_SETTINGS_TYPE_HID_DEVICES,
 208      IDS_SITE_SETTINGS_TYPE_HID_DEVICES_MID_SENTENCE},
 209     {ContentSettingsType::IMAGES, IDS_SITE_SETTINGS_TYPE_IMAGES,
 210      IDS_SITE_SETTINGS_TYPE_IMAGES_MID_SENTENCE},
 211     {ContentSettingsType::SERIAL_GUARD, IDS_SITE_SETTINGS_TYPE_SERIAL_PORTS,
 212      IDS_SITE_SETTINGS_TYPE_SERIAL_PORTS_MID_SENTENCE},
 213     {ContentSettingsType::WINDOW_MANAGEMENT,
 214      IDS_SITE_SETTINGS_TYPE_WINDOW_MANAGEMENT,
 215      IDS_SITE_SETTINGS_TYPE_WINDOW_MANAGEMENT_MID_SENTENCE},
 216 #endif
 217   };
 218   return kPermissionUIInfo;
 219 }
 220
 221 std::unique_ptr<PageInfoUI::SecurityDescription> CreateSecurityDescription(
 222     PageInfoUI::SecuritySummaryColor style,
 223     int summary_id,
 224     int details_id,
 225     PageInfoUI::SecurityDescriptionType type) {
 226   auto security_description =
 227       std::make_unique<PageInfoUI::SecurityDescription>();
 228   security_description->summary_style = style;
 229   if (summary_id)
 230     security_description->summary = l10n_util::GetStringUTF16(summary_id);
 231   if (details_id)
 232     security_description->details = l10n_util::GetStringUTF16(details_id);
 233   security_description->type = type;
 234   return security_description;
 235 }
 236
 237 std::unique_ptr<PageInfoUI::SecurityDescription>
 238 CreateSecurityDescriptionForSafetyTip(
 239     const security_state::SafetyTipStatus& safety_tip_status,
 240     const GURL& safe_url) {
 241   auto security_description =
 242       std::make_unique<PageInfoUI::SecurityDescription>();
 243   security_description->summary_style = PageInfoUI::SecuritySummaryColor::RED;
 244
 245   if (safety_tip_status == security_state::SafetyTipStatus::kBadReputation ||
 246       safety_tip_status ==
 247           security_state::SafetyTipStatus::kBadReputationIgnored) {
 248     security_description->summary = l10n_util::GetStringUTF16(
 249         IDS_PAGE_INFO_SAFETY_TIP_BAD_REPUTATION_TITLE);
 250   } else {
 251     const std::u16string safe_host =
 252         security_interstitials::common_string_util::GetFormattedHostName(
 253             safe_url);
 254     security_description->summary = l10n_util::GetStringFUTF16(
 255         IDS_PAGE_INFO_SAFETY_TIP_LOOKALIKE_TITLE, safe_host);
 256   }
 257   security_description->details =
 258       l10n_util::GetStringUTF16(IDS_PAGE_INFO_SAFETY_TIP_DESCRIPTION);
 259   security_description->type = PageInfoUI::SecurityDescriptionType::SAFETY_TIP;
 260   return security_description;
 261 }
 262
 263 // Gets the actual setting for a ContentSettingType, taking into account what
 264 // the default setting value is and whether Html5ByDefault is enabled.
 265 ContentSetting GetEffectiveSetting(ContentSettingsType type,
 266                                    ContentSetting setting,
 267                                    ContentSetting default_setting) {
 268   ContentSetting effective_setting = setting;
 269   if (effective_setting == CONTENT_SETTING_DEFAULT)
 270     effective_setting = default_setting;
 271
 272   // Display the UI string for ASK instead of DETECT for Flash.
 273   // TODO(tommycli): Just migrate the actual content setting to ASK.
 274   if (effective_setting == CONTENT_SETTING_DETECT_IMPORTANT_CONTENT)
 275     effective_setting = CONTENT_SETTING_ASK;
 276
 277   return effective_setting;
 278 }
 279
 280 void SetTargetContentSetting(PageInfo::PermissionInfo& permission,
 281                              ContentSetting target_setting) {
 282   // If content setting's default setting matches target setting, set
 283   // default setting to avoid crearing a site exception.
 284   permission.setting = permission.default_setting == target_setting
 285                            ? CONTENT_SETTING_DEFAULT
 286                            : target_setting;
 287 }
 288
 289 void CreateOppositeToDefaultSiteException(
 290     PageInfo::PermissionInfo& permission,
 291     ContentSetting opposite_to_block_setting) {
 292   // For guard content settings opposite to block setting is ask, for the
 293   // rest opposite is allow.
 294   permission.setting = permission.default_setting == opposite_to_block_setting
 295                            ? CONTENT_SETTING_BLOCK
 296                            : opposite_to_block_setting;
 297 }
 298
 299 std::u16string GetPermissionAskStateString(ContentSettingsType type) {
 300   int message_id = kInvalidResourceID;
 301
 302   switch (type) {
 303     case ContentSettingsType::GEOLOCATION:
 304       message_id = IDS_PAGE_INFO_STATE_TEXT_LOCATION_ASK;
 305       break;
 306     case ContentSettingsType::NOTIFICATIONS:
 307       message_id = IDS_PAGE_INFO_STATE_TEXT_NOTIFICATIONS_ASK;
 308       break;
 309     case ContentSettingsType::MIDI_SYSEX:
 310       message_id = IDS_PAGE_INFO_STATE_TEXT_MIDI_ASK;
 311       break;
 312     case ContentSettingsType::MEDIASTREAM_CAMERA:
 313       message_id = IDS_PAGE_INFO_STATE_TEXT_CAMERA_ASK;
 314       break;
 315     case ContentSettingsType::CAMERA_PAN_TILT_ZOOM:
 316       message_id = IDS_PAGE_INFO_STATE_TEXT_CAMERA_PAN_TILT_ZOOM_ASK;
 317       break;
 318     case ContentSettingsType::MEDIASTREAM_MIC:
 319       message_id = IDS_PAGE_INFO_STATE_TEXT_MIC_ASK;
 320       break;
 321     case ContentSettingsType::CLIPBOARD_READ_WRITE:
 322       message_id = IDS_PAGE_INFO_STATE_TEXT_CLIPBOARD_ASK;
 323       break;
 324     case ContentSettingsType::AUTOMATIC_DOWNLOADS:
 325       message_id = IDS_PAGE_INFO_STATE_TEXT_AUTOMATIC_DOWNLOADS_ASK;
 326       break;
 327     case ContentSettingsType::VR:
 328       message_id = IDS_PAGE_INFO_STATE_TEXT_VR_ASK;
 329       break;
 330     case ContentSettingsType::AR:
 331       message_id = IDS_PAGE_INFO_STATE_TEXT_AR_ASK;
 332       break;
 333     case ContentSettingsType::WINDOW_MANAGEMENT:
 334       message_id = IDS_PAGE_INFO_STATE_TEXT_WINDOW_MANAGEMENT_ASK;
 335       break;
 336     case ContentSettingsType::LOCAL_FONTS:
 337       message_id = IDS_PAGE_INFO_STATE_TEXT_FONT_ACCESS_ASK;
 338       break;
 339     case ContentSettingsType::IDLE_DETECTION:
 340       message_id = IDS_PAGE_INFO_STATE_TEXT_IDLE_DETECTION_ASK;
 341       break;
 342     // Guard content settings:
 343     case ContentSettingsType::USB_GUARD:
 344       message_id = IDS_PAGE_INFO_STATE_TEXT_USB_ASK;
 345       break;
 346     case ContentSettingsType::HID_GUARD:
 347       message_id = IDS_PAGE_INFO_STATE_TEXT_HID_DEVICES_ASK;
 348       break;
 349     case ContentSettingsType::SERIAL_GUARD:
 350       message_id = IDS_PAGE_INFO_STATE_TEXT_SERIAL_ASK;
 351       break;
 352     case ContentSettingsType::BLUETOOTH_GUARD:
 353       message_id = IDS_PAGE_INFO_STATE_TEXT_BLUETOOTH_DEVICES_ASK;
 354       break;
 355     case ContentSettingsType::BLUETOOTH_SCANNING:
 356       message_id = IDS_PAGE_INFO_STATE_TEXT_BLUETOOTH_SCANNING_ASK;
 357       break;
 358     case ContentSettingsType::FILE_SYSTEM_WRITE_GUARD:
 359       message_id = IDS_PAGE_INFO_STATE_TEXT_FILE_SYSTEM_WRITE_ASK;
 360       break;
 361     default:
 362       NOTREACHED();
 363   }
 364
 365   if (message_id == kInvalidResourceID)
 366     return std::u16string();
 367   return l10n_util::GetStringUTF16(message_id);
 368 }
 369
 370 }  // namespace
 371
 372 PageInfoUI::CookieInfo::CookieInfo() : allowed(-1), blocked(-1) {}
 373
 374 PageInfoUI::CookiesNewInfo::CookiesNewInfo() = default;
 375
 376 PageInfoUI::CookiesNewInfo::~CookiesNewInfo() = default;
 377
 378 PageInfoUI::CookiesFpsInfo::CookiesFpsInfo(const std::u16string& owner_name)
 379     : owner_name(owner_name) {}
 380
 381 PageInfoUI::CookiesFpsInfo::~CookiesFpsInfo() = default;
 382
 383 PageInfoUI::ChosenObjectInfo::ChosenObjectInfo(
 384     const PageInfo::ChooserUIInfo& ui_info,
 385     std::unique_ptr<permissions::ObjectPermissionContextBase::Object>
 386         chooser_object)
 387     : ui_info(ui_info), chooser_object(std::move(chooser_object)) {}
 388
 389 PageInfoUI::ChosenObjectInfo::~ChosenObjectInfo() = default;
 390
 391 PageInfoUI::IdentityInfo::IdentityInfo()
 392     : identity_status(PageInfo::SITE_IDENTITY_STATUS_UNKNOWN),
 393       safe_browsing_status(PageInfo::SAFE_BROWSING_STATUS_NONE),
 394       safety_tip_info({security_state::SafetyTipStatus::kUnknown, GURL()}),
 395       connection_status(PageInfo::SITE_CONNECTION_STATUS_UNKNOWN),
 396       show_ssl_decision_revoke_button(false),
 397       show_change_password_buttons(false) {}
 398
 399 PageInfoUI::IdentityInfo::~IdentityInfo() = default;
 400
 401 PageInfoUI::PageFeatureInfo::PageFeatureInfo()
 402     : is_vr_presentation_in_headset(false) {}
 403
 404 bool PageInfoUI::AdPersonalizationInfo::is_empty() const {
 405   return !has_joined_user_to_interest_group && accessed_topics.empty();
 406 }
 407
 408 PageInfoUI::AdPersonalizationInfo::AdPersonalizationInfo() = default;
 409 PageInfoUI::AdPersonalizationInfo::~AdPersonalizationInfo() = default;
 410
 411 std::unique_ptr<PageInfoUI::SecurityDescription>
 412 PageInfoUI::GetSecurityDescription(const IdentityInfo& identity_info) const {
 413   switch (identity_info.safe_browsing_status) {
 414     case PageInfo::SAFE_BROWSING_STATUS_NONE:
 415       break;
 416     case PageInfo::SAFE_BROWSING_STATUS_MALWARE:
 417       return CreateSecurityDescription(SecuritySummaryColor::RED,
 418                                        IDS_PAGE_INFO_MALWARE_SUMMARY,
 419                                        IDS_PAGE_INFO_MALWARE_DETAILS,
 420                                        SecurityDescriptionType::SAFE_BROWSING);
 421     case PageInfo::SAFE_BROWSING_STATUS_SOCIAL_ENGINEERING:
 422       return CreateSecurityDescription(SecuritySummaryColor::RED,
 423                                        IDS_PAGE_INFO_SOCIAL_ENGINEERING_SUMMARY,
 424                                        IDS_PAGE_INFO_SOCIAL_ENGINEERING_DETAILS,
 425                                        SecurityDescriptionType::SAFE_BROWSING);
 426     case PageInfo::SAFE_BROWSING_STATUS_UNWANTED_SOFTWARE:
 427       return CreateSecurityDescription(SecuritySummaryColor::RED,
 428                                        IDS_PAGE_INFO_UNWANTED_SOFTWARE_SUMMARY,
 429                                        IDS_PAGE_INFO_UNWANTED_SOFTWARE_DETAILS,
 430                                        SecurityDescriptionType::SAFE_BROWSING);
 431     case PageInfo::SAFE_BROWSING_STATUS_SAVED_PASSWORD_REUSE: {
 432 #if BUILDFLAG(FULL_SAFE_BROWSING)
 433       auto security_description = CreateSecurityDescription(
 434           SecuritySummaryColor::RED,
 435           IDS_PAGE_INFO_CHANGE_PASSWORD_SAVED_PASSWORD_SUMMARY, 0,
 436           SecurityDescriptionType::SAFE_BROWSING);
 437       security_description->details = identity_info.safe_browsing_details;
 438       return security_description;
 439 #endif
 440       NOTREACHED();
 441       break;
 442     }
 443     case PageInfo::SAFE_BROWSING_STATUS_SIGNED_IN_SYNC_PASSWORD_REUSE:
 444     case PageInfo::SAFE_BROWSING_STATUS_SIGNED_IN_NON_SYNC_PASSWORD_REUSE:
 445     case PageInfo::SAFE_BROWSING_STATUS_ENTERPRISE_PASSWORD_REUSE: {
 446 #if BUILDFLAG(FULL_SAFE_BROWSING)
 447       auto security_description = CreateSecurityDescription(
 448           SecuritySummaryColor::RED, IDS_PAGE_INFO_CHANGE_PASSWORD_SUMMARY, 0,
 449           SecurityDescriptionType::SAFE_BROWSING);
 450       security_description->details = identity_info.safe_browsing_details;
 451       return security_description;
 452 #endif
 453       NOTREACHED();
 454       break;
 455     }
 456     case PageInfo::SAFE_BROWSING_STATUS_BILLING:
 457       return CreateSecurityDescription(SecuritySummaryColor::RED,
 458                                        IDS_PAGE_INFO_BILLING_SUMMARY,
 459                                        IDS_PAGE_INFO_BILLING_DETAILS,
 460                                        SecurityDescriptionType::SAFE_BROWSING);
 461   }
 462
 463   std::unique_ptr<SecurityDescription> safety_tip_security_desc =
 464       CreateSafetyTipSecurityDescription(identity_info.safety_tip_info);
 465   if (safety_tip_security_desc) {
 466     return safety_tip_security_desc;
 467   }
 468
 469   switch (identity_info.identity_status) {
 470 #if BUILDFLAG(IS_ANDROID)
 471     case PageInfo::SITE_IDENTITY_STATUS_INTERNAL_PAGE:
 472       return CreateSecurityDescription(SecuritySummaryColor::GREEN, 0,
 473                                        IDS_PAGE_INFO_INTERNAL_PAGE,
 474                                        SecurityDescriptionType::INTERNAL);
 475     case PageInfo::SITE_IDENTITY_STATUS_EV_CERT:
 476     case PageInfo::SITE_IDENTITY_STATUS_CERT:
 477     case PageInfo::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT:
 478       switch (identity_info.connection_status) {
 479         case PageInfo::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE:
 480           return CreateSecurityDescription(
 481               SecuritySummaryColor::RED, IDS_PAGE_INFO_NOT_SECURE_SUMMARY_SHORT,
 482               IDS_PAGE_INFO_NOT_SECURE_DETAILS,
 483               SecurityDescriptionType::CONNECTION);
 484         case PageInfo::SITE_CONNECTION_STATUS_INSECURE_FORM_ACTION:
 485           return CreateSecurityDescription(
 486               SecuritySummaryColor::RED,
 487               IDS_PAGE_INFO_MIXED_CONTENT_SUMMARY_SHORT,
 488               IDS_PAGE_INFO_NOT_SECURE_DETAILS,
 489               SecurityDescriptionType::CONNECTION);
 490         case PageInfo::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE:
 491           return CreateSecurityDescription(
 492               SecuritySummaryColor::RED,
 493               IDS_PAGE_INFO_MIXED_CONTENT_SUMMARY_SHORT,
 494               IDS_PAGE_INFO_MIXED_CONTENT_DETAILS,
 495               SecurityDescriptionType::CONNECTION);
 496         default:
 497           // Do not show details for secure connections.
 498           return CreateSecurityDescription(SecuritySummaryColor::GREEN,
 499                                            IDS_PAGE_INFO_SECURE_SUMMARY, 0,
 500                                            SecurityDescriptionType::CONNECTION);
 501       }
 502     case PageInfo::SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM:
 503     case PageInfo::SITE_IDENTITY_STATUS_UNKNOWN:
 504     case PageInfo::SITE_IDENTITY_STATUS_NO_CERT:
 505     default:
 506       return CreateSecurityDescription(SecuritySummaryColor::RED,
 507                                        IDS_PAGE_INFO_NOT_SECURE_SUMMARY_SHORT,
 508                                        IDS_PAGE_INFO_NOT_SECURE_DETAILS,
 509                                        SecurityDescriptionType::CONNECTION);
 510 #else
 511     case PageInfo::SITE_IDENTITY_STATUS_INTERNAL_PAGE:
 512       // Internal pages on desktop have their own UI implementations which
 513       // should never call this function.
 514       NOTREACHED();
 515       [[fallthrough]];
 516     case PageInfo::SITE_IDENTITY_STATUS_EV_CERT:
 517     case PageInfo::SITE_IDENTITY_STATUS_CERT:
 518     case PageInfo::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT:
 519       switch (identity_info.connection_status) {
 520         case PageInfo::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE:
 521           return CreateSecurityDescription(SecuritySummaryColor::RED,
 522                                            IDS_PAGE_INFO_NOT_SECURE_SUMMARY,
 523                                            IDS_PAGE_INFO_NOT_SECURE_DETAILS,
 524                                            SecurityDescriptionType::CONNECTION);
 525         case PageInfo::SITE_CONNECTION_STATUS_INSECURE_FORM_ACTION:
 526           return CreateSecurityDescription(SecuritySummaryColor::RED,
 527                                            IDS_PAGE_INFO_MIXED_CONTENT_SUMMARY,
 528                                            IDS_PAGE_INFO_NOT_SECURE_DETAILS,
 529                                            SecurityDescriptionType::CONNECTION);
 530         case PageInfo::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE:
 531           return CreateSecurityDescription(SecuritySummaryColor::RED,
 532                                            IDS_PAGE_INFO_MIXED_CONTENT_SUMMARY,
 533                                            IDS_PAGE_INFO_MIXED_CONTENT_DETAILS,
 534                                            SecurityDescriptionType::CONNECTION);
 535         default:
 536
 537           auto description = CreateSecurityDescription(
 538               SecuritySummaryColor::GREEN, IDS_PAGE_INFO_SECURE_SUMMARY,
 539               base::FeatureList::IsEnabled(
 540                   omnibox::kUpdatedConnectionSecurityIndicators)
 541                   ? IDS_PAGE_INFO_SECURE_DETAILS_V2
 542                   : IDS_PAGE_INFO_SECURE_DETAILS,
 543               SecurityDescriptionType::CONNECTION);
 544           if (identity_info.identity_status ==
 545               PageInfo::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT) {
 546             description->details = l10n_util::GetStringFUTF16(
 547                 IDS_PAGE_INFO_ADMIN_PROVIDED_CERT_DETAILS,
 548                 base::UTF8ToUTF16(identity_info.site_identity));
 549           }
 550           return description;
 551       }
 552     case PageInfo::SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM:
 553     case PageInfo::SITE_IDENTITY_STATUS_UNKNOWN:
 554     case PageInfo::SITE_IDENTITY_STATUS_NO_CERT:
 555     default:
 556       return CreateSecurityDescription(SecuritySummaryColor::RED,
 557                                        IDS_PAGE_INFO_NOT_SECURE_SUMMARY,
 558                                        IDS_PAGE_INFO_NOT_SECURE_DETAILS,
 559                                        SecurityDescriptionType::CONNECTION);
 560 #endif
 561   }
 562 }
 563
 564 PageInfoUI::~PageInfoUI() = default;
 565
 566 // static
 567 std::u16string PageInfoUI::PermissionTypeToUIString(ContentSettingsType type) {
 568   for (const PermissionUIInfo& info : GetContentSettingsUIInfo()) {
 569     if (info.type == type)
 570       return l10n_util::GetStringUTF16(info.string_id);
 571   }
 572   NOTREACHED();
 573   return std::u16string();
 574 }
 575
 576 // static
 577 std::u16string PageInfoUI::PermissionTypeToUIStringMidSentence(
 578     ContentSettingsType type) {
 579   for (const PermissionUIInfo& info : GetContentSettingsUIInfo()) {
 580     if (info.type == type)
 581       return l10n_util::GetStringUTF16(info.string_id_mid_sentence);
 582   }
 583   NOTREACHED();
 584   return std::u16string();
 585 }
 586
 587 // static
 588 base::span<const PageInfoUI::PermissionUIInfo>
 589 PageInfoUI::GetContentSettingsUIInfoForTesting() {
 590   return GetContentSettingsUIInfo();
 591 }
 592
 593 // static
 594 std::u16string PageInfoUI::PermissionActionToUIString(
 595     PageInfoUiDelegate* delegate,
 596     ContentSettingsType type,
 597     ContentSetting setting,
 598     ContentSetting default_setting,
 599     content_settings::SettingSource source,
 600     bool is_one_time) {
 601   ContentSetting effective_setting =
 602       GetEffectiveSetting(type, setting, default_setting);
 603   const int* button_text_ids = nullptr;
 604   switch (source) {
 605     case content_settings::SETTING_SOURCE_USER:
 606       if (setting == CONTENT_SETTING_DEFAULT) {
 607 #if !BUILDFLAG(IS_ANDROID)
 608         if (type == ContentSettingsType::SOUND) {
 609           // If the block autoplay enabled preference is enabled and the
 610           // sound default setting is ALLOW, we will return a custom string
 611           // indicating that Chrome is controlling autoplay and sound
 612           // automatically.
 613           if (delegate->IsBlockAutoPlayEnabled() &&
 614               effective_setting == ContentSetting::CONTENT_SETTING_ALLOW) {
 615             return l10n_util::GetStringUTF16(
 616                 IDS_PAGE_INFO_BUTTON_TEXT_AUTOMATIC_BY_DEFAULT);
 617           }
 618
 619           button_text_ids = kSoundPermissionButtonTextIDDefaultSetting;
 620           break;
 621         }
 622 #endif
 623         button_text_ids = kPermissionButtonTextIDDefaultSetting;
 624         break;
 625       }
 626       [[fallthrough]];
 627     case content_settings::SETTING_SOURCE_POLICY:
 628     case content_settings::SETTING_SOURCE_EXTENSION:
 629 #if !BUILDFLAG(IS_ANDROID)
 630       if (type == ContentSettingsType::SOUND) {
 631         button_text_ids = kSoundPermissionButtonTextIDUserManaged;
 632         break;
 633       }
 634 #endif
 635       button_text_ids = kPermissionButtonTextIDUserManaged;
 636       break;
 637     case content_settings::SETTING_SOURCE_ALLOWLIST:
 638     case content_settings::SETTING_SOURCE_NONE:
 639     default:
 640       NOTREACHED();
 641       return std::u16string();
 642   }
 643   int button_text_id = button_text_ids[effective_setting];
 644
 645   if (is_one_time) {
 646     DCHECK_EQ(source, content_settings::SETTING_SOURCE_USER);
 647     DCHECK_EQ(type, ContentSettingsType::GEOLOCATION);
 648     DCHECK_EQ(button_text_id, IDS_PAGE_INFO_BUTTON_TEXT_ALLOWED_BY_USER);
 649     button_text_id = IDS_PAGE_INFO_BUTTON_TEXT_ALLOWED_ONCE_BY_USER;
 650   }
 651   DCHECK_NE(button_text_id, kInvalidResourceID);
 652   return l10n_util::GetStringUTF16(button_text_id);
 653 }
 654
 655 // static
 656 std::u16string PageInfoUI::PermissionStateToUIString(
 657     PageInfoUiDelegate* delegate,
 658     const PageInfo::PermissionInfo& permission) {
 659   int message_id = kInvalidResourceID;
 660   ContentSetting effective_setting = GetEffectiveSetting(
 661       permission.type, permission.setting, permission.default_setting);
 662   switch (effective_setting) {
 663     case CONTENT_SETTING_ALLOW:
 664 #if !BUILDFLAG(IS_ANDROID)
 665       if (permission.type == ContentSettingsType::SOUND &&
 666           delegate->IsBlockAutoPlayEnabled() &&
 667           permission.setting == CONTENT_SETTING_DEFAULT) {
 668         message_id = IDS_PAGE_INFO_BUTTON_TEXT_AUTOMATIC_BY_DEFAULT;
 669         break;
 670       }
 671 #endif
 672       if (permission.setting == CONTENT_SETTING_DEFAULT) {
 673         message_id = IDS_PAGE_INFO_STATE_TEXT_ALLOWED_BY_DEFAULT;
 674 #if !BUILDFLAG(IS_ANDROID)
 675       } else if (permission.is_one_time) {
 676         DCHECK_EQ(permission.source, content_settings::SETTING_SOURCE_USER);
 677         DCHECK(permissions::PermissionUtil::CanPermissionBeAllowedOnce(
 678             permission.type));
 679         message_id = delegate->IsMultipleTabsOpen()
 680                          ? IDS_PAGE_INFO_STATE_TEXT_ALLOWED_ONCE_MULTIPLE_TAB
 681                          : IDS_PAGE_INFO_STATE_TEXT_ALLOWED_ONCE_ONE_TAB;
 682 #endif
 683       } else {
 684         message_id = IDS_PAGE_INFO_STATE_TEXT_ALLOWED;
 685       }
 686       break;
 687     case CONTENT_SETTING_BLOCK:
 688       if (permission.setting == CONTENT_SETTING_DEFAULT) {
 689 #if !BUILDFLAG(IS_ANDROID)
 690         if (permission.type == ContentSettingsType::SOUND) {
 691           message_id = IDS_PAGE_INFO_BUTTON_TEXT_MUTED_BY_DEFAULT;
 692           break;
 693         }
 694 #endif
 695         message_id = IDS_PAGE_INFO_STATE_TEXT_NOT_ALLOWED_BY_DEFAULT;
 696       } else {
 697 #if !BUILDFLAG(IS_ANDROID)
 698         if (permission.type == ContentSettingsType::SOUND) {
 699           message_id = IDS_PAGE_INFO_STATE_TEXT_MUTED;
 700           break;
 701         }
 702 #endif
 703         message_id = IDS_PAGE_INFO_STATE_TEXT_NOT_ALLOWED;
 704       }
 705       break;
 706     case CONTENT_SETTING_ASK:
 707       return GetPermissionAskStateString(permission.type);
 708     default:
 709       NOTREACHED();
 710   }
 711
 712   return l10n_util::GetStringUTF16(message_id);
 713 }
 714
 715 // static
 716 std::u16string PageInfoUI::PermissionMainPageStateToUIString(
 717     PageInfoUiDelegate* delegate,
 718     const PageInfo::PermissionInfo& permission) {
 719   std::u16string auto_blocked_text =
 720       PermissionAutoBlockedToUIString(delegate, permission);
 721   if (!auto_blocked_text.empty())
 722     return auto_blocked_text;
 723
 724   if (permission.is_one_time || permission.setting == CONTENT_SETTING_DEFAULT ||
 725       permission.setting == CONTENT_SETTING_ASK) {
 726     return PermissionStateToUIString(delegate, permission);
 727   }
 728
 729   return std::u16string();
 730 }
 731
 732 // static
 733 std::u16string PageInfoUI::PermissionManagedTooltipToUIString(
 734     PageInfoUiDelegate* delegate,
 735     const PageInfo::PermissionInfo& permission) {
 736   int message_id = kInvalidResourceID;
 737   switch (permission.source) {
 738     case content_settings::SettingSource::SETTING_SOURCE_POLICY:
 739       message_id = IDS_PAGE_INFO_PERMISSION_MANAGED_BY_POLICY;
 740       break;
 741     case content_settings::SettingSource::SETTING_SOURCE_EXTENSION:
 742       // TODO(crbug.com/1225563): Consider "enforced" instead of "managed".
 743       message_id = IDS_PAGE_INFO_PERMISSION_MANAGED_BY_EXTENSION;
 744       break;
 745     default:
 746       break;
 747   }
 748
 749   if (message_id == kInvalidResourceID)
 750     return std::u16string();
 751   return l10n_util::GetStringUTF16(message_id);
 752 }
 753
 754 // static
 755 std::u16string PageInfoUI::PermissionAutoBlockedToUIString(
 756     PageInfoUiDelegate* delegate,
 757     const PageInfo::PermissionInfo& permission) {
 758   int message_id = kInvalidResourceID;
 759   // TODO(crbug.com/1063023): PageInfo::PermissionInfo should be modified
 760   // to contain all needed information regarding Automatically Blocked flag.
 761   if (permission.setting == CONTENT_SETTING_BLOCK &&
 762       permissions::PermissionDecisionAutoBlocker::IsEnabledForContentSetting(
 763           permission.type)) {
 764     permissions::PermissionResult permission_result(
 765         CONTENT_SETTING_DEFAULT,
 766         permissions::PermissionStatusSource::UNSPECIFIED);
 767     if (permissions::PermissionUtil::IsPermission(permission.type)) {
 768       blink::PermissionType permission_type =
 769           permissions::PermissionUtil::ContentSettingTypeToPermissionType(
 770               permission.type);
 771       permission_result = delegate->GetPermissionResult(permission_type);
 772     } else if (permission.type == ContentSettingsType::FEDERATED_IDENTITY_API) {
 773       absl::optional<permissions::PermissionResult> embargo_result =
 774           delegate->GetEmbargoResult(permission.type);
 775       if (embargo_result)
 776         permission_result = *embargo_result;
 777     }
 778
 779     switch (permission_result.source) {
 780       case permissions::PermissionStatusSource::MULTIPLE_DISMISSALS:
 781         message_id = IDS_PAGE_INFO_PERMISSION_AUTOMATICALLY_BLOCKED;
 782         break;
 783       case permissions::PermissionStatusSource::MULTIPLE_IGNORES:
 784         message_id = IDS_PAGE_INFO_PERMISSION_AUTOMATICALLY_BLOCKED;
 785         break;
 786       default:
 787         break;
 788     }
 789   }
 790   if (message_id == kInvalidResourceID)
 791     return std::u16string();
 792   return l10n_util::GetStringUTF16(message_id);
 793 }
 794
 795 // static
 796 void PageInfoUI::ToggleBetweenAllowAndBlock(
 797     PageInfo::PermissionInfo& permission) {
 798   auto opposite_to_block_setting =
 799       permissions::PermissionUtil::IsGuardContentSetting(permission.type)
 800           ? CONTENT_SETTING_ASK
 801           : CONTENT_SETTING_ALLOW;
 802   switch (permission.setting) {
 803     case CONTENT_SETTING_ALLOW:
 804       DCHECK_EQ(opposite_to_block_setting, CONTENT_SETTING_ALLOW);
 805       if (permission.is_one_time) {
 806         permission.setting = CONTENT_SETTING_DEFAULT;
 807       } else {
 808         SetTargetContentSetting(permission, CONTENT_SETTING_BLOCK);
 809       }
 810       permission.is_one_time = false;
 811       break;
 812     case CONTENT_SETTING_BLOCK:
 813       SetTargetContentSetting(permission, opposite_to_block_setting);
 814       permission.is_one_time = false;
 815       break;
 816     case CONTENT_SETTING_DEFAULT: {
 817       CreateOppositeToDefaultSiteException(permission,
 818                                            opposite_to_block_setting);
 819       // If one-time permissions are supported, permission should go from
 820       // default state to allow once state, not directly to allow.
 821       if (permissions::PermissionUtil::CanPermissionBeAllowedOnce(
 822               permission.type)) {
 823         permission.is_one_time = true;
 824       }
 825       break;
 826     }
 827     case CONTENT_SETTING_ASK:
 828       DCHECK_EQ(opposite_to_block_setting, CONTENT_SETTING_ASK);
 829       SetTargetContentSetting(permission, CONTENT_SETTING_BLOCK);
 830       break;
 831     default:
 832       NOTREACHED();
 833       break;
 834   }
 835 }
 836
 837 // static
 838 void PageInfoUI::ToggleBetweenRememberAndForget(
 839     PageInfo::PermissionInfo& permission) {
 840   DCHECK(permissions::PermissionUtil::IsPermission(permission.type));
 841   switch (permission.setting) {
 842     case CONTENT_SETTING_ALLOW: {
 843       // If one-time permissions are supported, toggle is_one_time.
 844       // Otherwise, go directly to default.
 845       if (permissions::PermissionUtil::CanPermissionBeAllowedOnce(
 846               permission.type)) {
 847         permission.is_one_time = !permission.is_one_time;
 848       } else {
 849         permission.setting = CONTENT_SETTING_DEFAULT;
 850       }
 851       break;
 852     }
 853     case CONTENT_SETTING_BLOCK:
 854       // TODO(olesiamarukhno): If content setting is in the blocklist, setting
 855       // it to default, doesn't do anything. Fix this before introducing
 856       // subpages for content settings (not permissions).
 857       permission.setting = CONTENT_SETTING_DEFAULT;
 858       permission.is_one_time = false;
 859       break;
 860     case CONTENT_SETTING_DEFAULT:
 861       // When user checks the checkbox to remember the permission setting,
 862       // it should go to the "allow" state, only if default setting is
 863       // explicitly allow.
 864       if (permission.default_setting == CONTENT_SETTING_ALLOW) {
 865         permission.setting = CONTENT_SETTING_ALLOW;
 866       } else {
 867         permission.setting = CONTENT_SETTING_BLOCK;
 868       }
 869       break;
 870     default:
 871       NOTREACHED();
 872       break;
 873   }
 874 }
 875
 876 // static
 877 bool PageInfoUI::IsToggleOn(const PageInfo::PermissionInfo& permission) {
 878   ContentSetting effective_setting = GetEffectiveSetting(
 879       permission.type, permission.setting, permission.default_setting);
 880   return permissions::PermissionUtil::IsGuardContentSetting(permission.type)
 881              ? effective_setting == CONTENT_SETTING_ASK
 882              : effective_setting == CONTENT_SETTING_ALLOW;
 883 }
 884
 885 // static
 886 SkColor PageInfoUI::GetSecondaryTextColor() {
 887   return SK_ColorGRAY;
 888 }
 889
 890 #if BUILDFLAG(IS_ANDROID)
 891 // static
 892 int PageInfoUI::GetIdentityIconID(PageInfo::SiteIdentityStatus status) {
 893   switch (status) {
 894     case PageInfo::SITE_IDENTITY_STATUS_UNKNOWN:
 895     case PageInfo::SITE_IDENTITY_STATUS_INTERNAL_PAGE:
 896     case PageInfo::SITE_IDENTITY_STATUS_CERT:
 897     case PageInfo::SITE_IDENTITY_STATUS_EV_CERT:
 898       return IDR_PAGEINFO_GOOD;
 899     case PageInfo::SITE_IDENTITY_STATUS_NO_CERT:
 900     case PageInfo::SITE_IDENTITY_STATUS_ERROR:
 901     case PageInfo::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT:
 902     case PageInfo::SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM:
 903       return IDR_PAGEINFO_BAD;
 904   }
 905
 906   return 0;
 907 }
 908
 909 // static
 910 int PageInfoUI::GetConnectionIconID(PageInfo::SiteConnectionStatus status) {
 911   switch (status) {
 912     case PageInfo::SITE_CONNECTION_STATUS_UNKNOWN:
 913     case PageInfo::SITE_CONNECTION_STATUS_INTERNAL_PAGE:
 914     case PageInfo::SITE_CONNECTION_STATUS_ENCRYPTED:
 915       return IDR_PAGEINFO_GOOD;
 916     case PageInfo::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE:
 917     case PageInfo::SITE_CONNECTION_STATUS_INSECURE_FORM_ACTION:
 918     case PageInfo::SITE_CONNECTION_STATUS_UNENCRYPTED:
 919     case PageInfo::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE:
 920     case PageInfo::SITE_CONNECTION_STATUS_ENCRYPTED_ERROR:
 921       return IDR_PAGEINFO_BAD;
 922   }
 923
 924   return 0;
 925 }
 926
 927 int PageInfoUI::GetIdentityIconColorID(PageInfo::SiteIdentityStatus status) {
 928   switch (status) {
 929     case PageInfo::SITE_IDENTITY_STATUS_UNKNOWN:
 930     case PageInfo::SITE_IDENTITY_STATUS_INTERNAL_PAGE:
 931     case PageInfo::SITE_IDENTITY_STATUS_CERT:
 932     case PageInfo::SITE_IDENTITY_STATUS_EV_CERT:
 933       return IDR_PAGEINFO_GOOD_COLOR;
 934     case PageInfo::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT:
 935     case PageInfo::SITE_IDENTITY_STATUS_NO_CERT:
 936     case PageInfo::SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM:
 937       return IDR_PAGEINFO_WARNING_COLOR;
 938     case PageInfo::SITE_IDENTITY_STATUS_ERROR:
 939       return IDR_PAGEINFO_BAD_COLOR;
 940   }
 941   return 0;
 942 }
 943
 944 int PageInfoUI::GetConnectionIconColorID(
 945     PageInfo::SiteConnectionStatus status) {
 946   switch (status) {
 947     case PageInfo::SITE_CONNECTION_STATUS_UNKNOWN:
 948     case PageInfo::SITE_CONNECTION_STATUS_INTERNAL_PAGE:
 949     case PageInfo::SITE_CONNECTION_STATUS_ENCRYPTED:
 950       return IDR_PAGEINFO_GOOD_COLOR;
 951     case PageInfo::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE:
 952     case PageInfo::SITE_CONNECTION_STATUS_INSECURE_FORM_ACTION:
 953     case PageInfo::SITE_CONNECTION_STATUS_UNENCRYPTED:
 954       return IDR_PAGEINFO_WARNING_COLOR;
 955     case PageInfo::SITE_CONNECTION_STATUS_INSECURE_ACTIVE_SUBRESOURCE:
 956     case PageInfo::SITE_CONNECTION_STATUS_ENCRYPTED_ERROR:
 957       return IDR_PAGEINFO_BAD_COLOR;
 958   }
 959   return 0;
 960 }
 961
 962 #endif  // BUILDFLAG(IS_ANDROID)
 963
 964 // static
 965 bool PageInfoUI::ContentSettingsTypeInPageInfo(ContentSettingsType type) {
 966   for (const PermissionUIInfo& info : GetContentSettingsUIInfo()) {
 967     if (info.type == type)
 968       return true;
 969   }
 970   return false;
 971 }
 972
 973 // static
 974 std::unique_ptr<PageInfoUI::SecurityDescription>
 975 PageInfoUI::CreateSafetyTipSecurityDescription(
 976     const security_state::SafetyTipInfo& info) {
 977   switch (info.status) {
 978     case security_state::SafetyTipStatus::kBadReputation:
 979     case security_state::SafetyTipStatus::kBadReputationIgnored:
 980     case security_state::SafetyTipStatus::kLookalike:
 981     case security_state::SafetyTipStatus::kLookalikeIgnored:
 982       return CreateSecurityDescriptionForSafetyTip(info.status, info.safe_url);
 983
 984     case security_state::SafetyTipStatus::kBadKeyword:
 985       // Keyword safety tips are only used to collect metrics for now and are
 986       // not visible to the user, so don't affect Page Info.
 987       break;
 988
 989     case security_state::SafetyTipStatus::kDigitalAssetLinkMatch:
 990     case security_state::SafetyTipStatus::kNone:
 991     case security_state::SafetyTipStatus::kUnknown:
 992       break;
 993   }
 994   return nullptr;
 995 }