Remove SetSelectedTab() and deprecate unused WebsiteSettingsAction values.

chrome/browser/ui/website_settings/website_settings_unittest.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/website_settings/website_settings.h"
 
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
@@ skipping 56 matching lines @@
   connection_status &= ~net::SSL_CONNECTION_CIPHERSUITE_MASK;
   return cipher_suite | connection_status;
 }
 
 class MockWebsiteSettingsUI : public WebsiteSettingsUI {
  public:
   virtual ~MockWebsiteSettingsUI() {}
   MOCK_METHOD1(SetCookieInfo, void(const CookieInfoList& cookie_info_list));
   MOCK_METHOD0(SetPermissionInfoStub, void());
   MOCK_METHOD1(SetIdentityInfo, void(const IdentityInfo& identity_info));
-  MOCK_METHOD1(SetSelectedTab, void(TabId tab_id));
 
   void SetPermissionInfo(
       const PermissionInfoList& permission_info_list,
       ChosenObjectInfoList chosen_object_info_list) override {
     SetPermissionInfoStub();
     if (set_permission_info_callback_) {
       set_permission_info_callback_.Run(permission_info_list,
                                         std::move(chosen_object_info_list));
     }
   }
@@ skipping 131 matching lines @@
   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
 
   // SetPermissionInfo() is called once initially, and then again every time
   // OnSitePermissionChanged() is called.
 #if !BUILDFLAG(ENABLE_PLUGINS)
   // SetPermissionInfo for plugins didn't get called.
   EXPECT_CALL(*mock_ui(), SetPermissionInfoStub()).Times(6);
 #else
   EXPECT_CALL(*mock_ui(), SetPermissionInfoStub()).Times(7);
 #endif
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(
-      WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   // Execute code under tests.
   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_POPUPS,
                                               CONTENT_SETTING_ALLOW);
 #if BUILDFLAG(ENABLE_PLUGINS)
   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_PLUGINS,
                                               CONTENT_SETTING_BLOCK);
 #endif
   website_settings()->OnSitePermissionChanged(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                               CONTENT_SETTING_ALLOW);
@@ skipping 24 matching lines @@
   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
   setting = content_settings->GetContentSetting(
       url(), url(), CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, std::string());
   EXPECT_EQ(setting, CONTENT_SETTING_ALLOW);
 }
 
 TEST_F(WebsiteSettingsTest, OnSiteDataAccessed) {
   EXPECT_CALL(*mock_ui(), SetPermissionInfoStub());
   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
   EXPECT_CALL(*mock_ui(), SetCookieInfo(_)).Times(2);
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(
-      WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   website_settings()->OnSiteDataAccessed();
 }
 
 TEST_F(WebsiteSettingsTest, OnChosenObjectDeleted) {
   scoped_refptr<device::UsbDevice> device =
       new device::MockUsbDevice(0, 0, "Google", "Gizmo", "1234567890");
   usb_service().AddDevice(device);
   UsbChooserContext* store = UsbChooserContextFactory::GetForProfile(profile());
   store->GrantDevicePermission(url(), url(), device->guid());
 
   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
-  EXPECT_CALL(*mock_ui(),
-              SetSelectedTab(WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   // Access WebsiteSettings so that SetPermissionInfo is called once to populate
   // |last_chosen_object_info_|. It will be called again by
   // OnSiteChosenObjectDeleted.
   EXPECT_CALL(*mock_ui(), SetPermissionInfoStub()).Times(2);
   website_settings();
 
   ASSERT_EQ(1u, last_chosen_object_info().size());
   const WebsiteSettingsUI::ChosenObjectInfo* info =
       last_chosen_object_info()[0].get();
   website_settings()->OnSiteChosenObjectDeleted(info->ui_info, *info->object);
 
   EXPECT_FALSE(store->HasDevicePermission(url(), url(), device));
   EXPECT_EQ(0u, last_chosen_object_info().size());
 }
 
 TEST_F(WebsiteSettingsTest, Malware) {
   security_info_.security_level = security_state::DANGEROUS;
   security_info_.malicious_content_status =
       security_state::MALICIOUS_CONTENT_STATUS_MALWARE;
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(),
-              SetSelectedTab(WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_MALWARE,
             website_settings()->site_identity_status());
 }
 
 TEST_F(WebsiteSettingsTest, SocialEngineering) {
   security_info_.security_level = security_state::DANGEROUS;
   security_info_.malicious_content_status =
       security_state::MALICIOUS_CONTENT_STATUS_SOCIAL_ENGINEERING;
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(),
-              SetSelectedTab(WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_SOCIAL_ENGINEERING,
             website_settings()->site_identity_status());
 }
 
 TEST_F(WebsiteSettingsTest, UnwantedSoftware) {
   security_info_.security_level = security_state::DANGEROUS;
   security_info_.malicious_content_status =
       security_state::MALICIOUS_CONTENT_STATUS_UNWANTED_SOFTWARE;
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(),
-              SetSelectedTab(WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_UNWANTED_SOFTWARE,
             website_settings()->site_identity_status());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPConnection) {
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(
-      WebsiteSettingsUI::TAB_ID_PERMISSIONS));
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_UNENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_NO_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSConnection) {
   security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(
-      WebsiteSettingsUI::TAB_ID_PERMISSIONS));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, InsecureContent) {
   struct TestCase {
@@ skipping 116 matching lines @@
     security_info_.security_bits = 81;  // No error if > 80.
     security_info_.mixed_content_status = test.mixed_content_status;
     security_info_.content_with_cert_errors_status =
         test.content_with_cert_errors_status;
     int status = 0;
     status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
     status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
     security_info_.connection_status = status;
 
     SetDefaultUIExpectations(mock_ui());
-    EXPECT_CALL(*mock_ui(),
-                SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
     EXPECT_EQ(test.expected_site_connection_status,
               website_settings()->site_connection_status());
     EXPECT_EQ(test.expected_site_identity_status,
               website_settings()->site_identity_status());
     EXPECT_EQ(test.expected_connection_icon_id,
               WebsiteSettingsUI::GetConnectionIconID(
                   website_settings()->site_connection_status()));
     EXPECT_EQ(base::string16(), website_settings()->organization_name());
   }
@@ skipping 11 matching lines @@
   security_info_.cert_status = net::CERT_STATUS_IS_EV;
   security_info_.security_bits = 81;  // No error if > 80.
   security_info_.mixed_content_status =
       security_state::CONTENT_STATUS_DISPLAYED;
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(
       WebsiteSettings::SITE_CONNECTION_STATUS_INSECURE_PASSIVE_SUBRESOURCE,
       website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_EV_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::UTF8ToUTF16("Google Inc"),
             website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSRevocationError) {
   security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   security_info_.cert_status = net::CERT_STATUS_UNABLE_TO_CHECK_REVOCATION;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT_REVOCATION_UNKNOWN,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSConnectionError) {
   security_info_.security_level = security_state::SECURE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   security_info_.cert_status = 0;
   security_info_.security_bits = -1;
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED_ERROR,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSPolicyCertConnection) {
   security_info_.security_level =
       security_state::SECURE_WITH_POLICY_INSTALLED_CERT;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::SITE_IDENTITY_STATUS_ADMIN_PROVIDED_CERT,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSSHA1Minor) {
   security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
   security_info_.sha1_deprecation_status =
       security_state::DEPRECATED_SHA1_MINOR;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::
                 SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM_MINOR,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
   EXPECT_EQ(IDR_PAGEINFO_WARNING_MINOR,
             WebsiteSettingsUI::GetIdentityIconID(
                 website_settings()->site_identity_status()));
 }
 
 TEST_F(WebsiteSettingsTest, HTTPSSHA1Major) {
   security_info_.security_level = security_state::NONE;
   security_info_.scheme_is_cryptographic = true;
   security_info_.certificate = cert();
   security_info_.cert_status = 0;
   security_info_.security_bits = 81;  // No error if > 80.
   int status = 0;
   status = SetSSLVersion(status, net::SSL_CONNECTION_VERSION_TLS1);
   status = SetSSLCipherSuite(status, CR_TLS_RSA_WITH_AES_256_CBC_SHA256);
   security_info_.connection_status = status;
   security_info_.sha1_deprecation_status =
       security_state::DEPRECATED_SHA1_MAJOR;
 
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(WebsiteSettingsUI::TAB_ID_CONNECTION));
 
   EXPECT_EQ(WebsiteSettings::SITE_CONNECTION_STATUS_ENCRYPTED,
             website_settings()->site_connection_status());
   EXPECT_EQ(WebsiteSettings::
                 SITE_IDENTITY_STATUS_DEPRECATED_SIGNATURE_ALGORITHM_MAJOR,
             website_settings()->site_identity_status());
   EXPECT_EQ(base::string16(), website_settings()->organization_name());
   EXPECT_EQ(IDR_PAGEINFO_BAD,
             WebsiteSettingsUI::GetIdentityIconID(
                 website_settings()->site_identity_status()));
 }
 
 #if !defined(OS_ANDROID)
 TEST_F(WebsiteSettingsTest, NoInfoBar) {
   SetDefaultUIExpectations(mock_ui());
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(
-      WebsiteSettingsUI::TAB_ID_PERMISSIONS));
   EXPECT_EQ(0u, infobar_service()->infobar_count());
   website_settings()->OnUIClosing();
   EXPECT_EQ(0u, infobar_service()->infobar_count());
 }
 
 TEST_F(WebsiteSettingsTest, ShowInfoBar) {
   EXPECT_CALL(*mock_ui(), SetIdentityInfo(_));
   EXPECT_CALL(*mock_ui(), SetCookieInfo(_));
 
   EXPECT_CALL(*mock_ui(), SetPermissionInfoStub()).Times(2);
 
-  EXPECT_CALL(*mock_ui(), SetSelectedTab(
-      WebsiteSettingsUI::TAB_ID_PERMISSIONS));
   EXPECT_EQ(0u, infobar_service()->infobar_count());
   website_settings()->OnSitePermissionChanged(
       CONTENT_SETTINGS_TYPE_GEOLOCATION, CONTENT_SETTING_ALLOW);
   website_settings()->OnUIClosing();
   ASSERT_EQ(1u, infobar_service()->infobar_count());
 
   infobar_service()->RemoveInfoBar(infobar_service()->infobar_at(0));
 }
 #endif
 
@@ skipping 54 matching lines @@
     security_info_.security_level = test.security_level;
     ResetMockUI();
     ClearWebsiteSettings();
     SetDefaultUIExpectations(mock_ui());
 
     histograms.ExpectTotalCount(kGenericHistogram, 0);
     histograms.ExpectTotalCount(test.histogram_name, 0);
 
     website_settings()->RecordWebsiteSettingsAction(
         WebsiteSettings::WebsiteSettingsAction::
-            WEBSITE_SETTINGS_PERMISSIONS_TAB_SELECTED);
+            WEBSITE_SETTINGS_OPENED);
 
     // RecordWebsiteSettingsAction() is called during WebsiteSettings
     // creation in addition to the explicit RecordWebsiteSettingsAction()
     // call, so it is called twice in total.
     histograms.ExpectTotalCount(kGenericHistogram, 2);
     histograms.ExpectBucketCount(
         kGenericHistogram,
-        WebsiteSettings::WebsiteSettingsAction::WEBSITE_SETTINGS_OPENED, 1);
-    histograms.ExpectBucketCount(kGenericHistogram,
-                                 WebsiteSettings::WebsiteSettingsAction::
-                                     WEBSITE_SETTINGS_PERMISSIONS_TAB_SELECTED,
-                                 1);
+        WebsiteSettings::WebsiteSettingsAction::WEBSITE_SETTINGS_OPENED, 2);
 
     histograms.ExpectTotalCount(test.histogram_name, 2);
     histograms.ExpectBucketCount(
         test.histogram_name,
-        WebsiteSettings::WebsiteSettingsAction::WEBSITE_SETTINGS_OPENED, 1);
-    histograms.ExpectBucketCount(test.histogram_name,
-                                 WebsiteSettings::WebsiteSettingsAction::
-                                     WEBSITE_SETTINGS_PERMISSIONS_TAB_SELECTED,
-                                 1);
+        WebsiteSettings::WebsiteSettingsAction::WEBSITE_SETTINGS_OPENED, 2);
   }
 }