Rename WebsiteSettings code to PageInfo.

chrome/browser/ui/cocoa/page_info/page_info_bubble_controller.mm

 // Copyright 2014 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.
 
-#import "chrome/browser/ui/cocoa/page_info/website_settings_bubble_controller.h"
+#import "chrome/browser/ui/cocoa/page_info/page_info_bubble_controller.h"
 
 #import <AppKit/AppKit.h>
 
 #include <cmath>
 
 #include "base/i18n/rtl.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/sys_string_conversions.h"
 #import "chrome/browser/certificate_viewer.h"
@@ skipping 26 matching lines @@
 #import "ui/base/cocoa/controls/hyperlink_button_cell.h"
 #import "ui/base/cocoa/flipped_view.h"
 #import "ui/base/cocoa/hover_image_button.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
 #include "ui/gfx/scoped_ns_graphics_context_save_gstate_mac.h"
 #include "ui/resources/grit/ui_resources.h"
 
-using ChosenObjectInfoPtr =
-    std::unique_ptr<WebsiteSettingsUI::ChosenObjectInfo>;
+using ChosenObjectInfoPtr = std::unique_ptr<PageInfoUI::ChosenObjectInfo>;
 using ChosenObjectDeleteCallback =
-    base::Callback<void(const WebsiteSettingsUI::ChosenObjectInfo&)>;
+    base::Callback<void(const PageInfoUI::ChosenObjectInfo&)>;
 
 namespace {
 
 // General ---------------------------------------------------------------------
 
 // The default width of the window, in view coordinates. It may be larger to
 // fit the content.
 const CGFloat kDefaultWindowWidth = 320;
 
 // Padding around each section
@@ skipping 42 matching lines @@
 // Padding between the window frame and content for the internal page bubble.
 const CGFloat kInternalPageFramePadding = 10;
 
 // Spacing between the image and text for internal pages.
 const CGFloat kInternalPageImageSpacing = 10;
 
 // -----------------------------------------------------------------------------
 
 // NOTE: This assumes that there will never be more than one website settings
 // popup shown, and that the one that is shown is associated with the current
-// window. This matches the behaviour in views: see WebsiteSettingsPopupView.
+// window. This matches the behaviour in views: see PageInfoPopupView.
 bool g_is_popup_showing = false;
 
 // Takes in the parent window, which should be a BrowserWindow, and gets the
 // proper anchor point for the bubble. The returned point is in screen
 // coordinates.
 NSPoint AnchorPointForWindow(NSWindow* parent) {
   BrowserWindowController* controller = [parent windowController];
   NSPoint origin = NSZeroPoint;
   if ([controller isKindOfClass:[BrowserWindowController class]]) {
     LocationBarViewMac* location_bar = [controller locationBarBridge];
@@ skipping 45 matching lines @@
   }
   return self;
 }
 
 - (void)deleteClicked:(id)sender {
   callback_.Run(*objectInfo_);
 }
 
 @end
 
-@implementation WebsiteSettingsBubbleController
+@implementation PageInfoBubbleController
 
 - (CGFloat)defaultWindowWidth {
   return kDefaultWindowWidth;
 }
 
 bool IsInternalURL(const GURL& url) {
   return url.SchemeIs(content::kChromeUIScheme) ||
          url.SchemeIs(content::kChromeDevToolsScheme) ||
          url.SchemeIs(extensions::kExtensionScheme) ||
          url.SchemeIs(content::kViewSourceScheme);
 }
 
 - (id)initWithParentWindow:(NSWindow*)parentWindow
-    websiteSettingsUIBridge:(WebsiteSettingsUIBridge*)bridge
-                webContents:(content::WebContents*)webContents
-                        url:(const GURL&)url {
+          PageInfoUIBridge:(PageInfoUIBridge*)bridge
+               webContents:(content::WebContents*)webContents
+                       url:(const GURL&)url {
   DCHECK(parentWindow);
 
   webContents_ = webContents;
   permissionsPresent_ = NO;
   url_ = url;
 
   // Use an arbitrary height; it will be changed in performLayout.
   NSRect contentRect = NSMakeRect(0, 0, [self defaultWindowWidth], 1);
   // Create an empty window into which content is placed.
   base::scoped_nsobject<InfoBubbleWindow> window([[InfoBubbleWindow alloc]
@@ skipping 37 matching lines @@
   return Profile::FromBrowserContext(webContents_->GetBrowserContext());
 }
 
 - (void)windowWillClose:(NSNotification*)notification {
   if (presenter_.get())
     presenter_->OnUIClosing();
   presenter_.reset();
   [super windowWillClose:notification];
 }
 
-- (void)setPresenter:(WebsiteSettings*)presenter {
+- (void)setPresenter:(PageInfo*)presenter {
   presenter_.reset(presenter);
 }
 
 // Create the subviews for the bubble for internal Chrome pages.
 - (void)initializeContentsForInternalPage:(const GURL&)url {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
 
   int text = IDS_PAGE_INFO_INTERNAL_PAGE;
   int icon = IDR_PRODUCT_LOGO_16;
   if (url.SchemeIs(extensions::kExtensionScheme)) {
@@ skipping 117 matching lines @@
   [siteSettingsButton_ setTarget:self];
   [siteSettingsButton_ setAction:@selector(showSiteSettingsData:)];
 
   return siteSettingsSectionView.get();
 }
 
 // Handler for the link button below the list of cookies.
 - (void)showCookiesAndSiteData:(id)sender {
   DCHECK(webContents_);
   DCHECK(presenter_);
-  presenter_->RecordWebsiteSettingsAction(
-      WebsiteSettings::WEBSITE_SETTINGS_COOKIES_DIALOG_OPENED);
+  presenter_->RecordPageInfoAction(
+      PageInfo::WEBSITE_SETTINGS_COOKIES_DIALOG_OPENED);
   TabDialogs::FromWebContents(webContents_)->ShowCollectedCookies();
 }
 
 // Handler for the site settings button below the list of permissions.
 - (void)showSiteSettingsData:(id)sender {
   DCHECK(webContents_);
   DCHECK(presenter_);
-  presenter_->RecordWebsiteSettingsAction(
-      WebsiteSettings::WEBSITE_SETTINGS_SITE_SETTINGS_OPENED);
+  presenter_->RecordPageInfoAction(
+      PageInfo::WEBSITE_SETTINGS_SITE_SETTINGS_OPENED);
   webContents_->OpenURL(content::OpenURLParams(
       GURL(chrome::kChromeUIContentSettingsURL), content::Referrer(),
       WindowOpenDisposition::NEW_FOREGROUND_TAB, ui::PAGE_TRANSITION_LINK,
       false));
 }
 
 // TODO(lgarron): Move some of this to the presenter for separation of concerns
 // and platform unification. (https://crbug.com/571533)
 - (void)openConnectionHelp:(id)sender {
   DCHECK(webContents_);
   DCHECK(presenter_);
-  presenter_->RecordWebsiteSettingsAction(
-      WebsiteSettings::WEBSITE_SETTINGS_CONNECTION_HELP_OPENED);
+  presenter_->RecordPageInfoAction(
+      PageInfo::WEBSITE_SETTINGS_CONNECTION_HELP_OPENED);
   webContents_->OpenURL(content::OpenURLParams(
       GURL(chrome::kPageInfoHelpCenterURL), content::Referrer(),
       WindowOpenDisposition::NEW_FOREGROUND_TAB, ui::PAGE_TRANSITION_LINK,
       false));
 }
 
 // Handler for the link button to show certificate information.
 - (void)showCertificateInfo:(id)sender {
   DCHECK(certificate_.get());
   DCHECK(presenter_);
-  presenter_->RecordWebsiteSettingsAction(
-      WebsiteSettings::WEBSITE_SETTINGS_CERTIFICATE_DIALOG_OPENED);
+  presenter_->RecordPageInfoAction(
+      PageInfo::WEBSITE_SETTINGS_CERTIFICATE_DIALOG_OPENED);
   ShowCertificateViewer(webContents_, [self parentWindow], certificate_.get());
 }
 
 // Handler for the link button to revoke user certificate decisions.
 - (void)resetCertificateDecisions:(id)sender {
   DCHECK(resetDecisionsButton_);
   presenter_->OnRevokeSSLErrorBypassButtonPressed();
   [self close];
 }
 
@@ skipping 238 matching lines @@
 
   [button setFrame:buttonFrame];
   [button setButtonType:NSMomentaryPushInButton];
   [button setBezelStyle:NSRegularSquareBezelStyle];
   [view addSubview:button.get()];
 
   return button.get();
 }
 
 // Set the content of the identity and identity status fields.
-- (void)setIdentityInfo:(const WebsiteSettingsUI::IdentityInfo&)identityInfo {
-  std::unique_ptr<WebsiteSettingsUI::SecurityDescription> security_description =
+- (void)setIdentityInfo:(const PageInfoUI::IdentityInfo&)identityInfo {
+  std::unique_ptr<PageInfoUI::SecurityDescription> security_description =
       identityInfo.GetSecurityDescription();
   [securitySummaryField_
       setStringValue:base::SysUTF16ToNSString(security_description->summary)];
 
   [securityDetailsField_
       setStringValue:SysUTF16ToNSString(security_description->details)];
 
   certificate_ = identityInfo.certificate;
 
   if (certificate_ && identityInfo.show_ssl_decision_revoke_button) {
@@ skipping 15 matching lines @@
                              toView:securitySectionView_];
     [resetDecisionsButton_ setTarget:self];
     [resetDecisionsButton_ setAction:@selector(resetCertificateDecisions:)];
   }
 
   [self performLayout];
 }
 
 // Add a pop-up button for |permissionInfo| to the given view.
 - (NSPopUpButton*)addPopUpButtonForPermission:
-                      (const WebsiteSettingsUI::PermissionInfo&)permissionInfo
+                      (const PageInfoUI::PermissionInfo&)permissionInfo
                                        toView:(NSView*)view
                                       atPoint:(NSPoint)point {
   GURL url = webContents_ ? webContents_->GetURL() : GURL();
-  __block WebsiteSettingsBubbleController* weakSelf = self;
+  __block PageInfoBubbleController* weakSelf = self;
   PermissionMenuModel::ChangeCallback callback =
-      base::BindBlock(^(const WebsiteSettingsUI::PermissionInfo& permission) {
+      base::BindBlock(^(const PageInfoUI::PermissionInfo& permission) {
         [weakSelf onPermissionChanged:permission.type to:permission.setting];
       });
   base::scoped_nsobject<PermissionSelectorButton> button(
       [[PermissionSelectorButton alloc] initWithPermissionInfo:permissionInfo
                                                         forURL:url
                                                   withCallback:callback
                                                        profile:[self profile]]);
 
   // Determine the largest possible size for this button.
   CGFloat maxTitleWidth =
       [button maxTitleWidthForContentSettingsType:permissionInfo.type
                                withDefaultSetting:permissionInfo.default_setting
                                           profile:[self profile]];
 
   // Ensure the containing view is large enough to contain the button with its
   // widest possible title.
   NSRect containerFrame = [view frame];
   containerFrame.size.width =
       std::max(NSWidth(containerFrame),
                point.x + maxTitleWidth + kSectionHorizontalPadding);
   [view setFrame:containerFrame];
   [view addSubview:button.get()];
   return button.get();
 }
 
 // Add a delete button for |objectInfo| to the given view.
 - (NSButton*)addDeleteButtonForChosenObject:(ChosenObjectInfoPtr)objectInfo
                                      toView:(NSView*)view
                                     atPoint:(NSPoint)point {
-  __block WebsiteSettingsBubbleController* weakSelf = self;
+  __block PageInfoBubbleController* weakSelf = self;
   auto callback =
-      base::BindBlock(^(const WebsiteSettingsUI::ChosenObjectInfo& objectInfo) {
+      base::BindBlock(^(const PageInfoUI::ChosenObjectInfo& objectInfo) {
         [weakSelf onChosenObjectDeleted:objectInfo];
       });
   base::scoped_nsobject<ChosenObjectDeleteButton> button(
       [[ChosenObjectDeleteButton alloc]
           initWithChosenObject:std::move(objectInfo)
                        atPoint:point
                   withCallback:callback]);
 
   // Ensure the containing view is large enough to contain the button.
   NSRect containerFrame = [view frame];
   containerFrame.size.width =
       std::max(NSWidth(containerFrame), point.x + kPermissionDeleteImageSize +
                                             kSectionHorizontalPadding);
   [view setFrame:containerFrame];
   [view addSubview:button.get()];
   return button.get();
 }
 
 // Called when the user changes the setting of a permission.
 - (void)onPermissionChanged:(ContentSettingsType)permissionType
                          to:(ContentSetting)newSetting {
   if (presenter_)
     presenter_->OnSitePermissionChanged(permissionType, newSetting);
 }
 
 // Called when the user revokes permission for a previously chosen object.
-- (void)onChosenObjectDeleted:(const WebsiteSettingsUI::ChosenObjectInfo&)info {
+- (void)onChosenObjectDeleted:(const PageInfoUI::ChosenObjectInfo&)info {
   if (presenter_)
     presenter_->OnSiteChosenObjectDeleted(info.ui_info, *info.object);
 }
 
 // Adds a new row to the UI listing the permissions. Returns the NSPoint of the
 // last UI element added (either the permission button, in LTR, or the text
 // label, in RTL).
-- (NSPoint)addPermission:
-               (const WebsiteSettingsUI::PermissionInfo&)permissionInfo
+- (NSPoint)addPermission:(const PageInfoUI::PermissionInfo&)permissionInfo
                   toView:(NSView*)view
                  atPoint:(NSPoint)point {
   base::string16 labelText =
-      WebsiteSettingsUI::PermissionTypeToUIString(permissionInfo.type);
+      PageInfoUI::PermissionTypeToUIString(permissionInfo.type);
   bool isRTL = base::i18n::IsRTL();
   base::scoped_nsobject<NSImage> image(
-      [WebsiteSettingsUI::GetPermissionIcon(permissionInfo)
-              .ToNSImage() retain]);
+      [PageInfoUI::GetPermissionIcon(permissionInfo).ToNSImage() retain]);
 
   NSPoint position;
   NSImageView* imageView;
   NSPopUpButton* button;
   NSTextField* label;
 
   CGFloat viewWidth = NSWidth([view frame]);
 
   if (isRTL) {
     point.x = NSWidth([view frame]) - kPermissionImageSize -
@@ skipping 91 matching lines @@
 }
 
 // Adds a new row to the UI listing the permissions. Returns the NSPoint of the
 // last UI element added (either the permission button, in LTR, or the text
 // label, in RTL).
 - (NSPoint)addChosenObject:(ChosenObjectInfoPtr)objectInfo
                     toView:(NSView*)view
                    atPoint:(NSPoint)point {
   base::string16 labelText = l10n_util::GetStringFUTF16(
       objectInfo->ui_info.label_string_id,
-      WebsiteSettingsUI::ChosenObjectToUIString(*objectInfo));
+      PageInfoUI::ChosenObjectToUIString(*objectInfo));
   bool isRTL = base::i18n::IsRTL();
   base::scoped_nsobject<NSImage> image(
-      [WebsiteSettingsUI::GetChosenObjectIcon(*objectInfo, false)
-              .ToNSImage() retain]);
+      [PageInfoUI::GetChosenObjectIcon(*objectInfo, false).ToNSImage() retain]);
 
   NSPoint position;
   NSImageView* imageView;
   NSButton* button;
   NSTextField* label;
 
   CGFloat viewWidth = NSWidth([view frame]);
 
   if (isRTL) {
     point.x = NSWidth([view frame]) - kPermissionImageSize -
@@ skipping 85 matching lines @@
   NSPoint controlOrigin = NSMakePoint(kSectionHorizontalPadding, 0);
 
   CGFloat viewWidth = NSWidth([cookiesView_ frame]);
 
   // Reset X for the cookie image.
   if (isRTL) {
     controlOrigin.x = viewWidth - kPermissionImageSize -
                       kPermissionImageSpacing - kSectionHorizontalPadding;
   }
 
-  WebsiteSettingsUI::PermissionInfo info;
+  PageInfoUI::PermissionInfo info;
   info.type = CONTENT_SETTINGS_TYPE_COOKIES;
   info.setting = CONTENT_SETTING_ALLOW;
   // info.default_setting, info.source, and info.is_incognito have not been set,
   // but GetPermissionIcon doesn't use any of those.
-  NSImage* image = WebsiteSettingsUI::GetPermissionIcon(info).ToNSImage();
+  NSImage* image = PageInfoUI::GetPermissionIcon(info).ToNSImage();
   NSImageView* imageView = [self addImageWithSize:[image size]
                                            toView:cookiesView_
                                           atPoint:controlOrigin];
   [imageView setImage:image];
 
   NSButton* cookiesButton =
       [self addLinkButtonWithText:base::SysUTF16ToNSString(label_text)
                            toView:cookiesView_];
   [cookiesButton setTarget:self];
   [cookiesButton setAction:@selector(showCookiesAndSiteData:)];
@@ skipping 73 matching lines @@
     controlOrigin.y += kPermissionsVerticalSpacing;
   }
 
   [permissionsView_ setFrameSize:NSMakeSize(NSWidth([permissionsView_ frame]),
                                             controlOrigin.y)];
   [self performLayout];
 }
 
 @end
 
-WebsiteSettingsUIBridge::WebsiteSettingsUIBridge(
-    content::WebContents* web_contents)
+PageInfoUIBridge::PageInfoUIBridge(content::WebContents* web_contents)
     : content::WebContentsObserver(web_contents),
       web_contents_(web_contents),
       bubble_controller_(nil) {
   DCHECK(!g_is_popup_showing);
   g_is_popup_showing = true;
 }
 
-WebsiteSettingsUIBridge::~WebsiteSettingsUIBridge() {
+PageInfoUIBridge::~PageInfoUIBridge() {
   DCHECK(g_is_popup_showing);
   g_is_popup_showing = false;
 }
 
-void WebsiteSettingsUIBridge::set_bubble_controller(
-    WebsiteSettingsBubbleController* controller) {
+void PageInfoUIBridge::set_bubble_controller(
+    PageInfoBubbleController* controller) {
   bubble_controller_ = controller;
 }
 
-void WebsiteSettingsUIBridge::Show(
-    gfx::NativeWindow parent,
-    Profile* profile,
-    content::WebContents* web_contents,
-    const GURL& virtual_url,
-    const security_state::SecurityInfo& security_info) {
+void PageInfoUIBridge::Show(gfx::NativeWindow parent,
+                            Profile* profile,
+                            content::WebContents* web_contents,
+                            const GURL& virtual_url,
+                            const security_state::SecurityInfo& security_info) {
   if (ui::MaterialDesignController::IsSecondaryUiMaterial()) {
     chrome::ShowWebsiteSettingsBubbleViewsAtPoint(
         gfx::ScreenPointFromNSPoint(AnchorPointForWindow(parent)), profile,
         web_contents, virtual_url, security_info);
     return;
   }
 
   // Don't show the popup if it's already being shown. Since this method is
   // called each time the location icon is clicked, each click toggles the popup
   // in and out.
   if (g_is_popup_showing)
     return;
 
   // Create the bridge. This will be owned by the bubble controller.
-  WebsiteSettingsUIBridge* bridge = new WebsiteSettingsUIBridge(web_contents);
+  PageInfoUIBridge* bridge = new PageInfoUIBridge(web_contents);
 
   // Create the bubble controller. It will dealloc itself when it closes,
   // resetting |g_is_popup_showing|.
-  WebsiteSettingsBubbleController* bubble_controller = [
-      [WebsiteSettingsBubbleController alloc] initWithParentWindow:parent
-                                           websiteSettingsUIBridge:bridge
-                                                       webContents:web_contents
-                                                               url:virtual_url];
+  PageInfoBubbleController* bubble_controller =
+      [[PageInfoBubbleController alloc] initWithParentWindow:parent
+                                            PageInfoUIBridge:bridge
+                                                 webContents:web_contents
+                                                         url:virtual_url];
 
   if (!IsInternalURL(virtual_url)) {
     // Initialize the presenter, which holds the model and controls the UI.
     // This is also owned by the bubble controller.
-    WebsiteSettings* presenter = new WebsiteSettings(
-        bridge, profile,
-        TabSpecificContentSettings::FromWebContents(web_contents), web_contents,
-        virtual_url, security_info);
+    PageInfo* presenter =
+        new PageInfo(bridge, profile,
+                     TabSpecificContentSettings::FromWebContents(web_contents),
+                     web_contents, virtual_url, security_info);
     [bubble_controller setPresenter:presenter];
   }
 
   [bubble_controller showWindow:nil];
 }
 
-void WebsiteSettingsUIBridge::SetIdentityInfo(
-    const WebsiteSettingsUI::IdentityInfo& identity_info) {
+void PageInfoUIBridge::SetIdentityInfo(
+    const PageInfoUI::IdentityInfo& identity_info) {
   [bubble_controller_ setIdentityInfo:identity_info];
 }
 
-void WebsiteSettingsUIBridge::RenderFrameDeleted(
+void PageInfoUIBridge::RenderFrameDeleted(
     content::RenderFrameHost* render_frame_host) {
   if (render_frame_host == web_contents_->GetMainFrame()) {
     [bubble_controller_ close];
   }
 }
 
-void WebsiteSettingsUIBridge::SetCookieInfo(
-    const CookieInfoList& cookie_info_list) {
+void PageInfoUIBridge::SetCookieInfo(const CookieInfoList& cookie_info_list) {
   [bubble_controller_ setCookieInfo:cookie_info_list];
 }
 
-void WebsiteSettingsUIBridge::SetPermissionInfo(
+void PageInfoUIBridge::SetPermissionInfo(
     const PermissionInfoList& permission_info_list,
     ChosenObjectInfoList chosen_object_info_list) {
   [bubble_controller_ setPermissionInfo:permission_info_list
                        andChosenObjects:std::move(chosen_object_info_list)];
 }