Replace PermissionType in chrome/ with ContentSettingsType

chrome/browser/permissions/permission_context_base_unittest.cc

 // 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.
 
 #include "chrome/browser/permissions/permission_context_base.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 20 matching lines @@
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings.h"
 #include "components/content_settings/core/common/content_settings_types.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/safe_browsing_db/test_database_manager.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/permissions/permission_request_manager.h"
 #endif
 
 const char* const kPermissionsKillSwitchFieldStudy =
@@ skipping 45 matching lines @@
   std::map<GURL, std::set<std::string>> permissions_blacklist_;
 
   DISALLOW_COPY_AND_ASSIGN(MockSafeBrowsingDatabaseManager);
 };
 
 }  // namespace
 
 class TestPermissionContext : public PermissionContextBase {
  public:
   TestPermissionContext(Profile* profile,
-                        const content::PermissionType permission_type,
                         const ContentSettingsType content_settings_type)
-      : PermissionContextBase(profile, permission_type, content_settings_type),
+      : PermissionContextBase(profile, content_settings_type),
         tab_context_updated_(false) {}
 
   ~TestPermissionContext() override {}
 
 #if defined(OS_ANDROID)
   PermissionQueueController* GetInfoBarController() {
     return GetQueueController();
   }
 #endif
 
@@ skipping 10 matching lines @@
     if (quit_closure_) {
       quit_closure_.Run();
       quit_closure_.Reset();
     }
   }
 
   ContentSetting GetContentSettingFromMap(const GURL& url_a,
                                           const GURL& url_b) {
     auto* map = HostContentSettingsMapFactory::GetForProfile(profile());
     return map->GetContentSetting(url_a.GetOrigin(), url_b.GetOrigin(),
-                                  content_settings_type(), std::string());
+                                  content_settings_storage_type(),
+                                  std::string());
   }
 
   void RequestPermission(content::WebContents* web_contents,
                          const PermissionRequestID& id,
                          const GURL& requesting_frame,
                          bool user_gesture,
                          const BrowserPermissionCallback& callback) override {
     base::RunLoop run_loop;
     quit_closure_ = run_loop.QuitClosure();
     PermissionContextBase::RequestPermission(web_contents, id, requesting_frame,
@@ skipping 46 matching lines @@
   // Callback for responding to a permission once the request has been completed
   // (valid URL, kill switch disabled, not blacklisted)
   base::Closure respond_permission_;
   DISALLOW_COPY_AND_ASSIGN(TestPermissionContext);
 };
 
 class TestKillSwitchPermissionContext : public TestPermissionContext {
  public:
   TestKillSwitchPermissionContext(
       Profile* profile,
-      const content::PermissionType permission_type,
       const ContentSettingsType content_settings_type)
-      : TestPermissionContext(profile, permission_type, content_settings_type),
+      : TestPermissionContext(profile, content_settings_type),
         field_trial_list_(base::MakeUnique<base::FieldTrialList>(
             base::MakeUnique<base::MockEntropyProvider>())) {}
 
   void ResetFieldTrialList() {
     // Destroy the existing FieldTrialList before creating a new one to avoid
     // a DCHECK.
     field_trial_list_.reset();
     field_trial_list_ = base::MakeUnique<base::FieldTrialList>(
         base::MakeUnique<base::MockEntropyProvider>());
     variations::testing::ClearAllVariationParams();
@@ skipping 40 matching lines @@
         break;
       case CONTENT_SETTING_ASK:
         manager->Closing();
         break;
       default:
         NOTREACHED();
     }
 #endif
   }
 
-  void TestAskAndDecide_TestContent(content::PermissionType permission,
-                                    ContentSettingsType content_settings_type,
+  void TestAskAndDecide_TestContent(ContentSettingsType content_settings_type,
                                     ContentSetting decision,
                                     bool persist) {
-    TestPermissionContext permission_context(profile(), permission,
-                                             content_settings_type);
+    TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url("https://www.google.com");
     NavigateAndCommit(url);
     base::HistogramTester histograms;
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(),
         -1);
     permission_context.SetRespondPermissionCallback(
         base::Bind(&PermissionContextBaseTests::RespondToPermission,
@@ skipping 12 matching lines @@
     if (decision == CONTENT_SETTING_ALLOW)
       decision_string = "Accepted";
     else if (decision == CONTENT_SETTING_BLOCK)
       decision_string = "Denied";
     else if (decision == CONTENT_SETTING_ASK)
       decision_string = "Dismissed";
 
     if (decision_string.size()) {
       histograms.ExpectUniqueSample(
           "Permissions.Prompt." + decision_string + ".PriorDismissCount." +
-              PermissionUtil::GetPermissionString(permission),
+              PermissionUtil::GetPermissionString(content_settings_type),
           0, 1);
       histograms.ExpectUniqueSample(
           "Permissions.Prompt." + decision_string + ".PriorIgnoreCount." +
-              PermissionUtil::GetPermissionString(permission),
+              PermissionUtil::GetPermissionString(content_settings_type),
           0, 1);
     }
 
     if (persist) {
       EXPECT_EQ(decision,
                 permission_context.GetContentSettingFromMap(url, url));
     } else {
       EXPECT_EQ(CONTENT_SETTING_ASK,
                 permission_context.GetContentSettingFromMap(url, url));
     }
 
     histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                   PermissionEmbargoStatus::NOT_EMBARGOED, 1);
   }
 
   void DismissMultipleTimesAndExpectBlock(
       const GURL& url,
-      content::PermissionType permission_type,
       ContentSettingsType content_settings_type,
       uint32_t iterations) {
     base::HistogramTester histograms;
 
     // Dismiss |iterations| times. The final dismiss should change the decision
     // from dismiss to block, and hence change the persisted content setting.
     for (uint32_t i = 0; i < iterations; ++i) {
       ContentSetting expected =
           (i < 2) ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK;
-      TestPermissionContext permission_context(
-          profile(), permission_type, content_settings_type);
+      TestPermissionContext permission_context(profile(),
+                                               content_settings_type);
       const PermissionRequestID id(
           web_contents()->GetRenderProcessHost()->GetID(),
           web_contents()->GetMainFrame()->GetRoutingID(), i);
 
       permission_context.SetRespondPermissionCallback(
           base::Bind(&PermissionContextBaseTests::RespondToPermission,
                      base::Unretained(this), &permission_context, id, url,
                      false, CONTENT_SETTING_ASK));
 
       permission_context.RequestPermission(
           web_contents(), id, url, true /* user_gesture */,
           base::Bind(&TestPermissionContext::TrackPermissionDecision,
                     base::Unretained(&permission_context)));
       histograms.ExpectTotalCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount." +
-              PermissionUtil::GetPermissionString(permission_type),
+              PermissionUtil::GetPermissionString(content_settings_type),
           i + 1);
       histograms.ExpectBucketCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount." +
-              PermissionUtil::GetPermissionString(permission_type),
+              PermissionUtil::GetPermissionString(content_settings_type),
           i, 1);
       histograms.ExpectTotalCount("Permissions.AutoBlocker.EmbargoStatus",
                                   i + 1);
       if (i < 2) {
         histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                       PermissionEmbargoStatus::NOT_EMBARGOED,
                                       i + 1);
       } else {
         histograms.ExpectBucketCount(
             "Permissions.AutoBlocker.EmbargoStatus",
             PermissionEmbargoStatus::REPEATED_DISMISSALS, 1);
       }
 
       ASSERT_EQ(1u, permission_context.decisions().size());
       EXPECT_EQ(CONTENT_SETTING_ASK, permission_context.decisions()[0]);
       EXPECT_TRUE(permission_context.tab_context_updated());
       PermissionResult result =
           permission_context.GetPermissionStatus(url, url);
       EXPECT_EQ(expected, result.content_setting);
       EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
     }
 
-    TestPermissionContext permission_context(profile(), permission_type,
-                                             content_settings_type);
+    TestPermissionContext permission_context(profile(), content_settings_type);
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
 
     permission_context.SetRespondPermissionCallback(
         base::Bind(&PermissionContextBaseTests::RespondToPermission,
                    base::Unretained(this), &permission_context, id, url, false,
                    CONTENT_SETTING_ASK));
 
     permission_context.RequestPermission(
         web_contents(), id, url, true /* user_gesture */,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     PermissionResult result = permission_context.GetPermissionStatus(url, url);
     EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
     EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
   }
 
   void TestBlockOnSeveralDismissals_TestContent() {
     GURL url("https://www.google.com");
     NavigateAndCommit(url);
     base::HistogramTester histograms;
 
     // First, ensure that > 3 dismissals behaves correctly.
     for (uint32_t i = 0; i < 4; ++i) {
       TestPermissionContext permission_context(
-          profile(), content::PermissionType::GEOLOCATION,
-          CONTENT_SETTINGS_TYPE_GEOLOCATION);
+          profile(), CONTENT_SETTINGS_TYPE_GEOLOCATION);
 
       const PermissionRequestID id(
           web_contents()->GetRenderProcessHost()->GetID(),
           web_contents()->GetMainFrame()->GetRoutingID(), i);
 
       permission_context.SetRespondPermissionCallback(
           base::Bind(&PermissionContextBaseTests::RespondToPermission,
                      base::Unretained(this), &permission_context, id, url,
                      false, CONTENT_SETTING_ASK));
       permission_context.RequestPermission(
@@ skipping 23 matching lines @@
         CONTENT_SETTINGS_TYPE_PERMISSION_AUTOBLOCKER_DATA);
 
     base::test::ScopedFeatureList feature_list;
     feature_list.InitAndEnableFeature(features::kBlockPromptsIfDismissedOften);
 
     EXPECT_TRUE(
         base::FeatureList::IsEnabled(features::kBlockPromptsIfDismissedOften));
 
     // Sanity check independence per permission type by checking two of them.
     DismissMultipleTimesAndExpectBlock(url,
-                                       content::PermissionType::GEOLOCATION,
                                        CONTENT_SETTINGS_TYPE_GEOLOCATION, 3);
     DismissMultipleTimesAndExpectBlock(url,
-                                       content::PermissionType::NOTIFICATIONS,
                                        CONTENT_SETTINGS_TYPE_NOTIFICATIONS, 3);
   }
 
   void TestVariationBlockOnSeveralDismissals_TestContent() {
     GURL url("https://www.google.com");
     NavigateAndCommit(url);
     base::HistogramTester histograms;
 
     // Set up the custom parameter and custom value.
     base::FieldTrialList field_trials(nullptr);
@@ skipping 19 matching lines @@
 
     {
       std::map<std::string, std::string> actual_params;
       EXPECT_TRUE(variations::GetVariationParamsByFeature(
           features::kBlockPromptsIfDismissedOften, &actual_params));
       EXPECT_EQ(params, actual_params);
     }
 
     for (uint32_t i = 0; i < 5; ++i) {
       TestPermissionContext permission_context(
-          profile(), content::PermissionType::MIDI_SYSEX,
-          CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
+          profile(), CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
 
       ContentSetting expected =
           (i < 4) ? CONTENT_SETTING_ASK : CONTENT_SETTING_BLOCK;
       const PermissionRequestID id(
           web_contents()->GetRenderProcessHost()->GetID(),
           web_contents()->GetMainFrame()->GetRoutingID(), i);
       permission_context.SetRespondPermissionCallback(
           base::Bind(&PermissionContextBaseTests::RespondToPermission,
                      base::Unretained(this), &permission_context, id, url,
                      false, CONTENT_SETTING_ASK));
@@ skipping 22 matching lines @@
                                       PermissionEmbargoStatus::NOT_EMBARGOED,
                                       i + 1);
       } else {
         histograms.ExpectBucketCount(
             "Permissions.AutoBlocker.EmbargoStatus",
             PermissionEmbargoStatus::REPEATED_DISMISSALS, 1);
       }
     }
 
     // Ensure that we finish in the block state.
-    TestPermissionContext permission_context(
-        profile(), content::PermissionType::MIDI_SYSEX,
-        CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
+    TestPermissionContext permission_context(profile(),
+                                             CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
     PermissionResult result = permission_context.GetPermissionStatus(url, url);
     EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
     EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
 
     variations::testing::ClearAllVariationParams();
   }
 
   void TestRequestPermissionInvalidUrl(
-      content::PermissionType permission_type,
       ContentSettingsType content_settings_type) {
-    TestPermissionContext permission_context(profile(), permission_type,
-                                             content_settings_type);
+    TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url;
     ASSERT_FALSE(url.is_valid());
     NavigateAndCommit(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(),
         -1);
     permission_context.RequestPermission(
         web_contents(),
         id, url, true /* user_gesture */,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
 
     ASSERT_EQ(1u, permission_context.decisions().size());
     EXPECT_EQ(CONTENT_SETTING_BLOCK, permission_context.decisions()[0]);
     EXPECT_TRUE(permission_context.tab_context_updated());
     EXPECT_EQ(CONTENT_SETTING_ASK,
               permission_context.GetContentSettingFromMap(url, url));
   }
 
-  void TestGrantAndRevoke_TestContent(content::PermissionType permission_type,
-                                      ContentSettingsType content_settings_type,
+  void TestGrantAndRevoke_TestContent(ContentSettingsType content_settings_type,
                                       ContentSetting expected_default) {
-    TestPermissionContext permission_context(profile(), permission_type,
-                                             content_settings_type);
+    TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url("https://www.google.com");
     NavigateAndCommit(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(),
         -1);
     permission_context.SetRespondPermissionCallback(
         base::Bind(&PermissionContextBaseTests::RespondToPermission,
                    base::Unretained(this), &permission_context, id, url, true,
@@ skipping 15 matching lines @@
     permission_context.ResetPermission(url.GetOrigin(), url.GetOrigin());
     ContentSetting setting_after_reset =
         permission_context.GetContentSettingFromMap(url, url);
     ContentSetting default_setting =
         HostContentSettingsMapFactory::GetForProfile(profile())
             ->GetDefaultContentSetting(content_settings_type, nullptr);
     EXPECT_EQ(default_setting, setting_after_reset);
   }
 
   void TestGlobalPermissionsKillSwitch(
-      content::PermissionType permission_type,
       ContentSettingsType content_settings_type) {
-    TestKillSwitchPermissionContext permission_context(
-        profile(), permission_type, content_settings_type);
+    TestKillSwitchPermissionContext permission_context(profile(),
+                                                       content_settings_type);
     permission_context.ResetFieldTrialList();
 
     EXPECT_FALSE(permission_context.IsPermissionKillSwitchOn());
     std::map<std::string, std::string> params;
-    params[PermissionUtil::GetPermissionString(permission_type)] =
+    params[PermissionUtil::GetPermissionString(content_settings_type)] =
         kPermissionsKillSwitchBlockedValue;
     variations::AssociateVariationParams(
         kPermissionsKillSwitchFieldStudy, kPermissionsKillSwitchTestGroup,
         params);
     base::FieldTrialList::CreateFieldTrial(kPermissionsKillSwitchFieldStudy,
                                            kPermissionsKillSwitchTestGroup);
     EXPECT_TRUE(permission_context.IsPermissionKillSwitchOn());
   }
 
   // Don't call this more than once in the same test, as it persists data to
   // HostContentSettingsMap.
   void TestParallelRequests(ContentSetting response) {
     TestPermissionContext permission_context(
-        profile(), content::PermissionType::NOTIFICATIONS,
-        CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+        profile(), CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
     GURL url("http://www.google.com");
     NavigateAndCommit(url);
 
     const PermissionRequestID id0(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), 0);
     const PermissionRequestID id1(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), 1);
 
@@ skipping 20 matching lines @@
 
     ASSERT_EQ(2u, permission_context.decisions().size());
     EXPECT_EQ(response, permission_context.decisions()[0]);
     EXPECT_EQ(response, permission_context.decisions()[1]);
     EXPECT_TRUE(permission_context.tab_context_updated());
 
     EXPECT_EQ(response, permission_context.GetContentSettingFromMap(url, url));
   }
 
   void TestPermissionsBlacklisting(
-      content::PermissionType permission_type,
       ContentSettingsType content_settings_type,
       scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> db_manager,
       const GURL& url,
       int timeout,
       ContentSetting expected_permission_status,
       PermissionEmbargoStatus expected_embargo_reason) {
     NavigateAndCommit(url);
     base::HistogramTester histograms;
     base::test::ScopedFeatureList scoped_feature_list;
     scoped_feature_list.InitAndEnableFeature(features::kPermissionsBlacklist);
-    TestPermissionContext permission_context(profile(), permission_type,
-                                             content_settings_type);
+    TestPermissionContext permission_context(profile(), content_settings_type);
     PermissionDecisionAutoBlocker::GetForProfile(profile())
         ->SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                              timeout);
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
 
     // A response only needs to be made to the permission request if we do not
     // expect he permission to be blacklisted, therefore set the response
     // callback.
@@ skipping 30 matching lines @@
     PermissionRequestManager::CreateForWebContents(web_contents());
 #endif
   }
 
   DISALLOW_COPY_AND_ASSIGN(PermissionContextBaseTests);
 };
 
 // Simulates clicking Accept. The permission should be granted and
 // saved for future use.
 TEST_F(PermissionContextBaseTests, TestAskAndGrantPersist) {
-  TestAskAndDecide_TestContent(content::PermissionType::NOTIFICATIONS,
-                               CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+  TestAskAndDecide_TestContent(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                CONTENT_SETTING_ALLOW, true);
 }
 
 // Simulates clicking Accept. The permission should be granted, but not
 // persisted.
 TEST_F(PermissionContextBaseTests, TestAskAndGrantNoPersist) {
-  TestAskAndDecide_TestContent(content::PermissionType::NOTIFICATIONS,
-                               CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+  TestAskAndDecide_TestContent(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                CONTENT_SETTING_ALLOW, false);
 }
 
 // Simulates clicking Block. The permission should be denied and
 // saved for future use.
 TEST_F(PermissionContextBaseTests, TestAskAndBlockPersist) {
-  TestAskAndDecide_TestContent(content::PermissionType::GEOLOCATION,
-                               CONTENT_SETTINGS_TYPE_GEOLOCATION,
+  TestAskAndDecide_TestContent(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                CONTENT_SETTING_BLOCK, true);
 }
 
 // Simulates clicking Block. The permission should be denied, but not persisted.
 TEST_F(PermissionContextBaseTests, TestAskAndBlockNoPersist) {
-  TestAskAndDecide_TestContent(content::PermissionType::GEOLOCATION,
-                               CONTENT_SETTINGS_TYPE_GEOLOCATION,
+  TestAskAndDecide_TestContent(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                CONTENT_SETTING_BLOCK, false);
 }
 
 // Simulates clicking Dismiss (X) in the infobar/bubble.
 // The permission should be denied but not saved for future use.
 TEST_F(PermissionContextBaseTests, TestAskAndDismiss) {
-  TestAskAndDecide_TestContent(content::PermissionType::MIDI_SYSEX,
-                               CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
+  TestAskAndDecide_TestContent(CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                                CONTENT_SETTING_ASK, false);
 }
 
 // Simulates clicking Dismiss (X) in the infobar/bubble with the block on too
 // many dismissals feature active. The permission should be blocked after
 // several dismissals.
 TEST_F(PermissionContextBaseTests, TestDismissUntilBlocked) {
   TestBlockOnSeveralDismissals_TestContent();
 }
 
 // Test setting a custom number of dismissals before block via variations.
 TEST_F(PermissionContextBaseTests, TestDismissVariations) {
   TestVariationBlockOnSeveralDismissals_TestContent();
 }
 
 // Simulates non-valid requesting URL.
 // The permission should be denied but not saved for future use.
 TEST_F(PermissionContextBaseTests, TestNonValidRequestingUrl) {
-  TestRequestPermissionInvalidUrl(content::PermissionType::GEOLOCATION,
-                                  CONTENT_SETTINGS_TYPE_GEOLOCATION);
-  TestRequestPermissionInvalidUrl(content::PermissionType::NOTIFICATIONS,
-                                  CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
-  TestRequestPermissionInvalidUrl(content::PermissionType::MIDI_SYSEX,
-                                  CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
-  TestRequestPermissionInvalidUrl(content::PermissionType::PUSH_MESSAGING,
-                                  CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+  TestRequestPermissionInvalidUrl(CONTENT_SETTINGS_TYPE_GEOLOCATION);
+  TestRequestPermissionInvalidUrl(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+  TestRequestPermissionInvalidUrl(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
+  TestRequestPermissionInvalidUrl(CONTENT_SETTINGS_TYPE_PUSH_MESSAGING);
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   TestRequestPermissionInvalidUrl(
-      content::PermissionType::PROTECTED_MEDIA_IDENTIFIER,
       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
 #endif
 }
 
 #if defined(OS_ANDROID)
 // This test is specific to Android because other platforms use bubbles.
 TEST_F(PermissionContextBaseTests, TestGrantAndRevokeWithInfobars) {
-  TestGrantAndRevoke_TestContent(content::PermissionType::GEOLOCATION,
-                                 CONTENT_SETTINGS_TYPE_GEOLOCATION,
+  TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                  CONTENT_SETTING_ASK);
-  TestGrantAndRevoke_TestContent(content::PermissionType::MIDI_SYSEX,
-                                 CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
+  TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                                  CONTENT_SETTING_ASK);
   TestGrantAndRevoke_TestContent(
-      content::PermissionType::PROTECTED_MEDIA_IDENTIFIER,
       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER, CONTENT_SETTING_ASK);
   // TODO(timvolodine): currently no test for
   // CONTENT_SETTINGS_TYPE_NOTIFICATIONS because notification permissions work
   // differently with infobars as compared to bubbles (crbug.com/453784).
 }
 #endif
 
 #if !defined(OS_ANDROID)
 // Simulates granting and revoking of permissions using permission bubbles.
 // This test shouldn't run on mobile because mobile platforms use infobars.
 TEST_F(PermissionContextBaseTests, TestGrantAndRevokeWithBubbles) {
-  TestGrantAndRevoke_TestContent(content::PermissionType::GEOLOCATION,
-                                 CONTENT_SETTINGS_TYPE_GEOLOCATION,
+  TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_GEOLOCATION,
                                  CONTENT_SETTING_ASK);
-  TestGrantAndRevoke_TestContent(content::PermissionType::NOTIFICATIONS,
-                                 CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+  TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
                                  CONTENT_SETTING_ASK);
-  TestGrantAndRevoke_TestContent(content::PermissionType::MIDI_SYSEX,
-                                 CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
-                                 CONTENT_SETTING_ASK);
-  TestGrantAndRevoke_TestContent(content::PermissionType::PUSH_MESSAGING,
-                                 CONTENT_SETTINGS_TYPE_NOTIFICATIONS,
+  TestGrantAndRevoke_TestContent(CONTENT_SETTINGS_TYPE_MIDI_SYSEX,
                                  CONTENT_SETTING_ASK);
 }
 #endif
 
 // Tests the global kill switch by enabling/disabling the Field Trials.
 TEST_F(PermissionContextBaseTests, TestGlobalKillSwitch) {
-  TestGlobalPermissionsKillSwitch(content::PermissionType::GEOLOCATION,
-                                  CONTENT_SETTINGS_TYPE_GEOLOCATION);
-  TestGlobalPermissionsKillSwitch(content::PermissionType::NOTIFICATIONS,
-                                  CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
-  TestGlobalPermissionsKillSwitch(content::PermissionType::MIDI_SYSEX,
-                                  CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
-  TestGlobalPermissionsKillSwitch(content::PermissionType::PUSH_MESSAGING,
-                                  CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
-  TestGlobalPermissionsKillSwitch(content::PermissionType::DURABLE_STORAGE,
-                                  CONTENT_SETTINGS_TYPE_DURABLE_STORAGE);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_GEOLOCATION);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_PUSH_MESSAGING);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_DURABLE_STORAGE);
 #if defined(OS_ANDROID) || defined(OS_CHROMEOS)
   TestGlobalPermissionsKillSwitch(
-      content::PermissionType::PROTECTED_MEDIA_IDENTIFIER,
       CONTENT_SETTINGS_TYPE_PROTECTED_MEDIA_IDENTIFIER);
 #endif
-  TestGlobalPermissionsKillSwitch(content::PermissionType::AUDIO_CAPTURE,
-                                  CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
-  TestGlobalPermissionsKillSwitch(content::PermissionType::VIDEO_CAPTURE,
-                                  CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
+  TestGlobalPermissionsKillSwitch(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
 }
 
 TEST_F(PermissionContextBaseTests, TestParallelRequestsAllowed) {
   TestParallelRequests(CONTENT_SETTING_ALLOW);
 }
 
 TEST_F(PermissionContextBaseTests, TestParallelRequestsBlocked) {
   TestParallelRequests(CONTENT_SETTING_BLOCK);
 }
 
 TEST_F(PermissionContextBaseTests, TestParallelRequestsDismissed) {
   TestParallelRequests(CONTENT_SETTING_ASK);
 }
 
 // Tests a blacklisted (URL, permission) pair has had its permission request
 // blocked.
 TEST_F(PermissionContextBaseTests, TestPermissionsBlacklistingBlocked) {
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
       new MockSafeBrowsingDatabaseManager(true /* perform_callback */);
   const GURL url("https://www.example.com");
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   TestPermissionsBlacklisting(
-      content::PermissionType::GEOLOCATION, CONTENT_SETTINGS_TYPE_GEOLOCATION,
+      CONTENT_SETTINGS_TYPE_GEOLOCATION,
       db_manager, url, 2000 /* timeout */, CONTENT_SETTING_BLOCK,
       PermissionEmbargoStatus::PERMISSIONS_BLACKLISTING);
 }
 
 // Tests that a URL that is blacklisted for one permission can still request
 // another and grant another.
 TEST_F(PermissionContextBaseTests, TestPermissionsBlacklistingAllowed) {
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
       new MockSafeBrowsingDatabaseManager(true /* perform_callback */);
   const GURL url("https://www.example.com");
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
-  TestPermissionsBlacklisting(content::PermissionType::NOTIFICATIONS,
-                              CONTENT_SETTINGS_TYPE_NOTIFICATIONS, db_manager,
+  TestPermissionsBlacklisting(CONTENT_SETTINGS_TYPE_NOTIFICATIONS, db_manager,
                               url, 2000 /* timeout */, CONTENT_SETTING_ALLOW,
                               PermissionEmbargoStatus::NOT_EMBARGOED);
 }