Rename WebsiteSettings code to PageInfo.

chrome/browser/ui/page_info/page_info.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "chrome/browser/ui/page_info/website_settings.h"
+#include "chrome/browser/ui/page_info/page_info.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/i18n/time_formatting.h"
 #include "base/macros.h"
@@ skipping 16 matching lines @@
 #include "chrome/browser/history/history_service_factory.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/permissions/chooser_context_base.h"
 #include "chrome/browser/permissions/permission_manager.h"
 #include "chrome/browser/permissions/permission_result.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate.h"
 #include "chrome/browser/ssl/chrome_ssl_host_state_delegate_factory.h"
-#include "chrome/browser/ui/page_info/website_settings_ui.h"
+#include "chrome/browser/ui/page_info/page_info_ui.h"
 #include "chrome/browser/usb/usb_chooser_context.h"
 #include "chrome/browser/usb/usb_chooser_context_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/grit/theme_resources.h"
 #include "components/content_settings/core/browser/content_settings_utils.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
@@ skipping 15 matching lines @@
 #include "third_party/boringssl/src/include/openssl/ssl.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/policy/policy_cert_service.h"
 #include "chrome/browser/chromeos/policy/policy_cert_service_factory.h"
 #endif
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/exclusive_access/exclusive_access_manager.h"
-#include "chrome/browser/ui/page_info/website_settings_infobar_delegate.h"
+#include "chrome/browser/ui/page_info/page_info_infobar_delegate.h"
 #endif
 
 using base::ASCIIToUTF16;
 using base::UTF8ToUTF16;
 using base::UTF16ToUTF8;
 using content::BrowserThread;
 
 namespace {
 
 // Events for UMA. Do not reorder or change!
 enum SSLCertificateDecisionsDidRevoke {
   USER_CERT_DECISIONS_NOT_REVOKED = 0,
   USER_CERT_DECISIONS_REVOKED,
   END_OF_SSL_CERTIFICATE_DECISIONS_DID_REVOKE_ENUM
 };
 
-// The list of content settings types to display on the Website Settings UI. THE
+// The list of content settings types to display on the Page Info UI. THE
 // ORDER OF THESE ITEMS IS IMPORTANT. To propose changing it, email
 // security-dev@chromium.org.
 ContentSettingsType kPermissionType[] = {
     CONTENT_SETTINGS_TYPE_GEOLOCATION,
     CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
     CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
     CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
     CONTENT_SETTINGS_TYPE_JAVASCRIPT,
 #if !defined(OS_ANDROID)
     CONTENT_SETTINGS_TYPE_PLUGINS,
     CONTENT_SETTINGS_TYPE_IMAGES,
 #endif
     CONTENT_SETTINGS_TYPE_POPUPS,
     CONTENT_SETTINGS_TYPE_BACKGROUND_SYNC,
     CONTENT_SETTINGS_TYPE_AUTOMATIC_DOWNLOADS,
     CONTENT_SETTINGS_TYPE_AUTOPLAY,
     CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
 };
 
-// Determines whether to show permission |type| in the Website Settings UI. Only
+// Determines whether to show permission |type| in the Page Info UI. Only
 // applies to permissions listed in |kPermissionType|.
 bool ShouldShowPermission(ContentSettingsType type) {
 #if !defined(OS_ANDROID)
   // Autoplay is Android-only at the moment.
   if (type == CONTENT_SETTINGS_TYPE_AUTOPLAY)
     return false;
 #endif
 
   return true;
 }
@@ skipping 30 matching lines @@
   if (net::IsCertStatusError(security_info.cert_status) &&
       !net::IsCertStatusMinorError(security_info.cert_status)) {
     return;
   }
   CheckContentStatus(security_info.content_with_cert_errors_status, displayed,
                      ran);
 }
 
 void GetSiteIdentityByMaliciousContentStatus(
     security_state::MaliciousContentStatus malicious_content_status,
-    WebsiteSettings::SiteIdentityStatus* status,
+    PageInfo::SiteIdentityStatus* status,
     base::string16* details) {
   switch (malicious_content_status) {
     case security_state::MALICIOUS_CONTENT_STATUS_NONE:
       NOTREACHED();
       break;
     case security_state::MALICIOUS_CONTENT_STATUS_MALWARE:
-      *status = WebsiteSettings::SITE_IDENTITY_STATUS_MALWARE;
+      *status = PageInfo::SITE_IDENTITY_STATUS_MALWARE;
       *details = l10n_util::GetStringUTF16(IDS_PAGEINFO_MALWARE_DETAILS);
       break;
     case security_state::MALICIOUS_CONTENT_STATUS_SOCIAL_ENGINEERING:
-      *status = WebsiteSettings::SITE_IDENTITY_STATUS_SOCIAL_ENGINEERING;
+      *status = PageInfo::SITE_IDENTITY_STATUS_SOCIAL_ENGINEERING;
       *details =
           l10n_util::GetStringUTF16(IDS_PAGEINFO_SOCIAL_ENGINEERING_DETAILS);
       break;
     case security_state::MALICIOUS_CONTENT_STATUS_UNWANTED_SOFTWARE:
-      *status = WebsiteSettings::SITE_IDENTITY_STATUS_UNWANTED_SOFTWARE;
+      *status = PageInfo::SITE_IDENTITY_STATUS_UNWANTED_SOFTWARE;
       *details =
           l10n_util::GetStringUTF16(IDS_PAGEINFO_UNWANTED_SOFTWARE_DETAILS);
       break;
   }
 }
 
 base::string16 GetSimpleSiteName(const GURL& url) {
   return url_formatter::FormatUrlForSecurityDisplay(
       url, url_formatter::SchemeDisplay::OMIT_HTTP_AND_HTTPS);
 }
 
 ChooserContextBase* GetUsbChooserContext(Profile* profile) {
   return UsbChooserContextFactory::GetForProfile(profile);
 }
 
 // The list of chooser types that need to display entries in the Website
 // Settings UI. THE ORDER OF THESE ITEMS IS IMPORTANT. To propose changing it,
 // email security-dev@chromium.org.
-WebsiteSettings::ChooserUIInfo kChooserUIInfo[] = {
+PageInfo::ChooserUIInfo kChooserUIInfo[] = {
     {CONTENT_SETTINGS_TYPE_USB_CHOOSER_DATA, &GetUsbChooserContext,
-     IDR_BLOCKED_USB, IDR_ALLOWED_USB, IDS_WEBSITE_SETTINGS_USB_DEVICE_LABEL,
-     IDS_WEBSITE_SETTINGS_DELETE_USB_DEVICE, "name"},
+     IDR_BLOCKED_USB, IDR_ALLOWED_USB, IDS_PAGE_INFO_USB_DEVICE_LABEL,
+     IDS_PAGE_INFO_DELETE_USB_DEVICE, "name"},
 };
 
 }  // namespace
 
-WebsiteSettings::WebsiteSettings(
-    WebsiteSettingsUI* ui,
-    Profile* profile,
-    TabSpecificContentSettings* tab_specific_content_settings,
-    content::WebContents* web_contents,
-    const GURL& url,
-    const security_state::SecurityInfo& security_info)
+PageInfo::PageInfo(PageInfoUI* ui,
+                   Profile* profile,
+                   TabSpecificContentSettings* tab_specific_content_settings,
+                   content::WebContents* web_contents,
+                   const GURL& url,
+                   const security_state::SecurityInfo& security_info)
     : TabSpecificContentSettings::SiteDataObserver(
           tab_specific_content_settings),
       content::WebContentsObserver(web_contents),
       ui_(ui),
       show_info_bar_(false),
       site_url_(url),
       site_identity_status_(SITE_IDENTITY_STATUS_UNKNOWN),
       site_connection_status_(SITE_CONNECTION_STATUS_UNKNOWN),
       show_ssl_decision_revoke_button_(false),
       content_settings_(HostContentSettingsMapFactory::GetForProfile(profile)),
       chrome_ssl_host_state_delegate_(
           ChromeSSLHostStateDelegateFactory::GetForProfile(profile)),
       did_revoke_user_ssl_decisions_(false),
       profile_(profile),
       security_level_(security_state::NONE) {
   Init(url, security_info);
 
   PresentSitePermissions();
   PresentSiteData();
   PresentSiteIdentity();
 
-  // Every time the Website Settings UI is opened a |WebsiteSettings| object is
-  // created. So this counts how ofter the Website Settings UI is opened.
-  RecordWebsiteSettingsAction(WEBSITE_SETTINGS_OPENED);
+  // Every time the Page Info UI is opened a |PageInfo| object is
+  // created. So this counts how ofter the Page Info UI is opened.
+  RecordPageInfoAction(PAGE_INFO_OPENED);
 }
 
-WebsiteSettings::~WebsiteSettings() {}
+PageInfo::~PageInfo() {}
 
-void WebsiteSettings::RecordWebsiteSettingsAction(
-    WebsiteSettingsAction action) {
-  UMA_HISTOGRAM_ENUMERATION("WebsiteSettings.Action", action,
-                            WEBSITE_SETTINGS_COUNT);
+void PageInfo::RecordPageInfoAction(PageInfoAction action) {
+  UMA_HISTOGRAM_ENUMERATION("WebsiteSettings.Action", action, PAGE_INFO_COUNT);
 
   std::string histogram_name;
 
   if (site_url_.SchemeIsCryptographic()) {
     if (security_level_ == security_state::SECURE ||
         security_level_ == security_state::EV_SECURE) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Valid",
-                                action, WEBSITE_SETTINGS_COUNT);
+                                action, PAGE_INFO_COUNT);
     } else if (security_level_ == security_state::NONE) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Downgraded",
-                                action, WEBSITE_SETTINGS_COUNT);
+                                action, PAGE_INFO_COUNT);
     } else if (security_level_ == security_state::DANGEROUS) {
       UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpsUrl.Dangerous",
-                                action, WEBSITE_SETTINGS_COUNT);
+                                action, PAGE_INFO_COUNT);
     }
     return;
   }
 
   if (security_level_ == security_state::HTTP_SHOW_WARNING) {
     UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpUrl.Warning",
-                              action, WEBSITE_SETTINGS_COUNT);
+                              action, PAGE_INFO_COUNT);
   } else if (security_level_ == security_state::DANGEROUS) {
     UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpUrl.Dangerous",
-                              action, WEBSITE_SETTINGS_COUNT);
+                              action, PAGE_INFO_COUNT);
   } else {
     UMA_HISTOGRAM_ENUMERATION("Security.PageInfo.Action.HttpUrl.Neutral",
-                              action, WEBSITE_SETTINGS_COUNT);
+                              action, PAGE_INFO_COUNT);
   }
 }
 
-void WebsiteSettings::OnSitePermissionChanged(ContentSettingsType type,
-                                              ContentSetting setting) {
+void PageInfo::OnSitePermissionChanged(ContentSettingsType type,
+                                       ContentSetting setting) {
   // Count how often a permission for a specific content type is changed using
-  // the Website Settings UI.
+  // the Page Info UI.
   size_t num_values;
   int histogram_value = ContentSettingTypeToHistogramValue(type, &num_values);
   UMA_HISTOGRAM_ENUMERATION("WebsiteSettings.OriginInfo.PermissionChanged",
                             histogram_value, num_values);
 
   if (setting == ContentSetting::CONTENT_SETTING_ALLOW) {
     UMA_HISTOGRAM_ENUMERATION(
         "WebsiteSettings.OriginInfo.PermissionChanged.Allowed", histogram_value,
         num_values);
 
     if (type == CONTENT_SETTINGS_TYPE_PLUGINS) {
       rappor::SampleDomainAndRegistryFromGURL(
           g_browser_process->rappor_service(),
           "ContentSettings.Plugins.AddedAllowException", site_url_);
     }
   } else if (setting == ContentSetting::CONTENT_SETTING_BLOCK) {
     UMA_HISTOGRAM_ENUMERATION(
         "WebsiteSettings.OriginInfo.PermissionChanged.Blocked", histogram_value,
         num_values);
   }
 
   // This is technically redundant given the histogram above, but putting the
   // total count of permission changes in another histogram makes it easier to
-  // compare it against other kinds of actions in WebsiteSettings[PopupView].
-  RecordWebsiteSettingsAction(WEBSITE_SETTINGS_CHANGED_PERMISSION);
+  // compare it against other kinds of actions in PageInfo[PopupView].
+  RecordPageInfoAction(PAGE_INFO_CHANGED_PERMISSION);
 
   PermissionUtil::ScopedRevocationReporter scoped_revocation_reporter(
       this->profile_, this->site_url_, this->site_url_, type,
       PermissionSourceUI::OIB);
 
   content_settings_->SetNarrowestContentSetting(site_url_, site_url_, type,
                                                 setting);
 
   show_info_bar_ = true;
 
   // Refresh the UI to reflect the new setting.
   PresentSitePermissions();
 }
 
-void WebsiteSettings::OnSiteChosenObjectDeleted(
-    const ChooserUIInfo& ui_info,
-    const base::DictionaryValue& object) {
+void PageInfo::OnSiteChosenObjectDeleted(const ChooserUIInfo& ui_info,
+                                         const base::DictionaryValue& object) {
   // TODO(reillyg): Create metrics for revocations. crbug.com/556845
   ChooserContextBase* context = ui_info.get_context(profile_);
   const GURL origin = site_url_.GetOrigin();
   context->RevokeObjectPermission(origin, origin, object);
 
   show_info_bar_ = true;
 
   // Refresh the UI to reflect the changed settings.
   PresentSitePermissions();
 }
 
-void WebsiteSettings::OnSiteDataAccessed() {
+void PageInfo::OnSiteDataAccessed() {
   PresentSiteData();
 }
 
-void WebsiteSettings::OnUIClosing() {
+void PageInfo::OnUIClosing() {
 #if defined(OS_ANDROID)
   NOTREACHED();
 #else
   if (show_info_bar_ && web_contents() && !web_contents()->IsBeingDestroyed()) {
     InfoBarService* infobar_service =
         InfoBarService::FromWebContents(web_contents());
     if (infobar_service)
-      WebsiteSettingsInfoBarDelegate::Create(infobar_service);
+      PageInfoInfoBarDelegate::Create(infobar_service);
   }
 
   SSLCertificateDecisionsDidRevoke user_decision =
       did_revoke_user_ssl_decisions_ ? USER_CERT_DECISIONS_REVOKED
                                      : USER_CERT_DECISIONS_NOT_REVOKED;
 
   UMA_HISTOGRAM_ENUMERATION("interstitial.ssl.did_user_revoke_decisions",
                             user_decision,
                             END_OF_SSL_CERTIFICATE_DECISIONS_DID_REVOKE_ENUM);
 #endif
 }
 
-void WebsiteSettings::OnRevokeSSLErrorBypassButtonPressed() {
+void PageInfo::OnRevokeSSLErrorBypassButtonPressed() {
   DCHECK(chrome_ssl_host_state_delegate_);
   chrome_ssl_host_state_delegate_->RevokeUserAllowExceptionsHard(
       site_url().host());
   did_revoke_user_ssl_decisions_ = true;
 }
 
-void WebsiteSettings::Init(const GURL& url,
-                           const security_state::SecurityInfo& security_info) {
+void PageInfo::Init(const GURL& url,
+                    const security_state::SecurityInfo& security_info) {
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
   // On desktop, internal URLs aren't handled by this class. Instead, a
   // custom and simpler popup is shown.
   DCHECK(!url.SchemeIs(content::kChromeUIScheme) &&
          !url.SchemeIs(content::kChromeDevToolsScheme) &&
          !url.SchemeIs(content::kViewSourceScheme) &&
          !url.SchemeIs(content_settings::kExtensionScheme));
 #endif
 
   bool isChromeUINativeScheme = false;
@@ skipping 249 matching lines @@
   // Check if a user decision has been made to allow or deny certificates with
   // errors on this site.
   ChromeSSLHostStateDelegate* delegate =
       ChromeSSLHostStateDelegateFactory::GetForProfile(profile_);
   DCHECK(delegate);
   // Only show an SSL decision revoke button if the user has chosen to bypass
   // SSL host errors for this host in the past.
   show_ssl_decision_revoke_button_ = delegate->HasAllowException(url.host());
 }
 
-void WebsiteSettings::PresentSitePermissions() {
+void PageInfo::PresentSitePermissions() {
   PermissionInfoList permission_info_list;
   ChosenObjectInfoList chosen_object_info_list;
 
-  WebsiteSettingsUI::PermissionInfo permission_info;
+  PageInfoUI::PermissionInfo permission_info;
   for (size_t i = 0; i < arraysize(kPermissionType); ++i) {
     permission_info.type = kPermissionType[i];
 
     if (!ShouldShowPermission(permission_info.type))
       continue;
 
     content_settings::SettingInfo info;
     std::unique_ptr<base::Value> value = content_settings_->GetWebsiteSetting(
         site_url_, site_url_, permission_info.type, std::string(), &info);
     DCHECK(value.get());
@@ skipping 41 matching lines @@
 
     permission_info_list.push_back(permission_info);
   }
 
   for (const ChooserUIInfo& ui_info : kChooserUIInfo) {
     ChooserContextBase* context = ui_info.get_context(profile_);
     const GURL origin = site_url_.GetOrigin();
     auto chosen_objects = context->GetGrantedObjects(origin, origin);
     for (std::unique_ptr<base::DictionaryValue>& object : chosen_objects) {
       chosen_object_info_list.push_back(
-          base::MakeUnique<WebsiteSettingsUI::ChosenObjectInfo>(
-              ui_info, std::move(object)));
+          base::MakeUnique<PageInfoUI::ChosenObjectInfo>(ui_info,
+                                                         std::move(object)));
     }
   }
 
   ui_->SetPermissionInfo(permission_info_list,
                          std::move(chosen_object_info_list));
 }
 
-void WebsiteSettings::PresentSiteData() {
+void PageInfo::PresentSiteData() {
   CookieInfoList cookie_info_list;
   const LocalSharedObjectsContainer& allowed_objects =
       tab_specific_content_settings()->allowed_local_shared_objects();
   const LocalSharedObjectsContainer& blocked_objects =
       tab_specific_content_settings()->blocked_local_shared_objects();
 
   // Add first party cookie and site data counts.
-  WebsiteSettingsUI::CookieInfo cookie_info;
+  PageInfoUI::CookieInfo cookie_info;
   cookie_info.allowed = allowed_objects.GetObjectCountForDomain(site_url_);
   cookie_info.blocked = blocked_objects.GetObjectCountForDomain(site_url_);
   cookie_info.is_first_party = true;
   cookie_info_list.push_back(cookie_info);
 
   // Add third party cookie counts.
   cookie_info.allowed = allowed_objects.GetObjectCount() - cookie_info.allowed;
   cookie_info.blocked = blocked_objects.GetObjectCount() - cookie_info.blocked;
   cookie_info.is_first_party = false;
   cookie_info_list.push_back(cookie_info);
 
   ui_->SetCookieInfo(cookie_info_list);
 }
 
-void WebsiteSettings::PresentSiteIdentity() {
+void PageInfo::PresentSiteIdentity() {
   // After initialization the status about the site's connection and its
   // identity must be available.
   DCHECK_NE(site_identity_status_, SITE_IDENTITY_STATUS_UNKNOWN);
   DCHECK_NE(site_connection_status_, SITE_CONNECTION_STATUS_UNKNOWN);
-  WebsiteSettingsUI::IdentityInfo info;
+  PageInfoUI::IdentityInfo info;
   if (site_identity_status_ == SITE_IDENTITY_STATUS_EV_CERT)
     info.site_identity = UTF16ToUTF8(organization_name());
   else
     info.site_identity = UTF16ToUTF8(GetSimpleSiteName(site_url_));
 
   info.connection_status = site_connection_status_;
   info.connection_status_description = UTF16ToUTF8(site_connection_details_);
   info.identity_status = site_identity_status_;
   info.identity_status_description = UTF16ToUTF8(site_identity_details_);
   info.certificate = certificate_;
   info.show_ssl_decision_revoke_button = show_ssl_decision_revoke_button_;
   ui_->SetIdentityInfo(info);
 }