Convert AutoBlocker static class to KeyedService.

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 149 matching lines @@
       respond_permission_.Run();
       respond_permission_.Reset();
     } else {
       // Stop the run loop from spinning indefinitely if no response callback
       // has been set, as is the case with TestParallelRequests.
       quit_closure_.Run();
       quit_closure_.Reset();
     }
   }
 
-  // Permission request will need to be responded to, so pass a callback to be
-  // run once the request has completed and the decision has been made.
+  // Set the callback to run if the permission is being responded to in the
+  // test. This is left empty where no response is needed, such as in parallel
+  // requests, permissions blacklisting, invalid origin, and killswitch.
   void SetRespondPermissionCallback(base::Closure callback) {
     respond_permission_ = callback;
   }
 
  protected:
   void UpdateTabContext(const PermissionRequestID& id,
                         const GURL& requesting_origin,
                         bool allowed) override {
     tab_context_updated_ = true;
   }
@@ skipping 170 matching lines @@
               PermissionUtil::GetPermissionString(permission_type),
           i, 1);
       ASSERT_EQ(1u, permission_context.decisions().size());
       EXPECT_EQ(expected, permission_context.decisions()[0]);
       EXPECT_TRUE(permission_context.tab_context_updated());
       EXPECT_EQ(expected, permission_context.GetPermissionStatus(url, url));
     }
 
     TestPermissionContext permission_context(profile(), permission_type,
                                              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)));
 
     EXPECT_EQ(CONTENT_SETTING_BLOCK,
               permission_context.GetPermissionStatus(url, url));
   }
 
   void TestBlockOnSeveralDismissals_TestContent() {
     GURL url("https://www.google.com");
     NavigateAndCommit(url);
     base::HistogramTester histograms;
 
@@ skipping 109 matching lines @@
       histograms.ExpectTotalCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount.MidiSysEx", i + 1);
       histograms.ExpectBucketCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount.MidiSysEx", i, 1);
     }
 
     // Ensure that we finish in the block state.
     TestPermissionContext permission_context(
         profile(), content::PermissionType::MIDI_SYSEX,
         CONTENT_SETTINGS_TYPE_MIDI_SYSEX);
-
     EXPECT_EQ(CONTENT_SETTING_BLOCK,
               permission_context.GetPermissionStatus(url, url));
     variations::testing::ClearAllVariationParams();
   }
 
   void TestRequestPermissionInvalidUrl(
       content::PermissionType permission_type,
       ContentSettingsType content_settings_type) {
     TestPermissionContext permission_context(profile(), permission_type,
                                              content_settings_type);
@@ skipping 120 matching lines @@
 
     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 response) {
+      ContentSetting expected_permission_status) {
     NavigateAndCommit(url);
     base::test::ScopedFeatureList scoped_feature_list;
     scoped_feature_list.InitAndEnableFeature(features::kPermissionsBlacklist);
     TestPermissionContext permission_context(profile(), permission_type,
                                              content_settings_type);
-    permission_context.SetSafeBrowsingDatabaseManagerAndTimeoutForTest(
-        db_manager, timeout);
+    PermissionDecisionAutoBlocker::GetForProfile(profile())
+        ->SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
+                                                             timeout);
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
         web_contents()->GetMainFrame()->GetRoutingID(), -1);
-    // The response callback needs to be set here to test a response being made
-    // in the case of a site not being blacklisted or a safe browsing timeout.
-    permission_context.SetRespondPermissionCallback(base::Bind(
-        &PermissionContextBaseTests::RespondToPermission,
-        base::Unretained(this), &permission_context, id, url, false, response));
+
+    // 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.
+    if (expected_permission_status == CONTENT_SETTING_ALLOW) {
+      permission_context.SetRespondPermissionCallback(
+          base::Bind(&PermissionContextBaseTests::RespondToPermission,
+                     base::Unretained(this), &permission_context, id, url,
+                     true /* persist */, expected_permission_status));
+    }
+
     permission_context.RequestPermission(
         web_contents(), id, url, true /* user_gesture */,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
+    EXPECT_EQ(expected_permission_status,
+              permission_context.GetPermissionStatus(url, url));
 
-    ASSERT_EQ(1u, permission_context.decisions().size());
-    EXPECT_EQ(response, permission_context.decisions()[0]);
+    if (expected_permission_status == CONTENT_SETTING_ALLOW) {
+      ASSERT_EQ(1u, permission_context.decisions().size());
+      EXPECT_EQ(expected_permission_status, permission_context.decisions()[0]);
+    }
   }
 
  private:
   // ChromeRenderViewHostTestHarness:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
 #if defined(OS_ANDROID)
     InfoBarService::CreateForWebContents(web_contents());
 #else
     PermissionRequestManager::CreateForWebContents(web_contents());
@@ skipping 143 matching lines @@
 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{
-      PermissionUtil::GetPermissionString(
-          content::PermissionType::GEOLOCATION)};
+  std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   TestPermissionsBlacklisting(content::PermissionType::GEOLOCATION,
                               CONTENT_SETTINGS_TYPE_GEOLOCATION, db_manager,
                               url, 2000 /* timeout */, CONTENT_SETTING_BLOCK);
 }
 
-// Tests that a URL with a blacklisted permission is permitted to request a
-// non-blacklisted permission.
+// 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{
-      PermissionUtil::GetPermissionString(
-          content::PermissionType::GEOLOCATION)};
+  std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
-  TestPermissionsBlacklisting(
-      content::PermissionType::GEOLOCATION, CONTENT_SETTINGS_TYPE_GEOLOCATION,
-      db_manager, url, 2000 /* timeout in ms */, CONTENT_SETTING_BLOCK);
   TestPermissionsBlacklisting(content::PermissionType::NOTIFICATIONS,
                               CONTENT_SETTINGS_TYPE_NOTIFICATIONS, db_manager,
-                              url, 2000 /* timeout in ms */,
-                              CONTENT_SETTING_ALLOW);
+                              url, 2000 /* timeout */, CONTENT_SETTING_ALLOW);
 }
-
-// Tests that a URL with a blacklisted permisison is permitted to request that
-// permission if Safe Browsing has timed out.
-TEST_F(PermissionContextBaseTests, TestSafeBrowsingTimeout) {
-  scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
-      new MockSafeBrowsingDatabaseManager(false /* perform_callback */);
-  const GURL url("https://www.example.com");
-  std::set<std::string> blacklisted_permissions{
-      PermissionUtil::GetPermissionString(
-          content::PermissionType::GEOLOCATION)};
-  db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
-  TestPermissionsBlacklisting(content::PermissionType::GEOLOCATION,
-                              CONTENT_SETTINGS_TYPE_GEOLOCATION, db_manager,
-                              url, 0 /* timeout in ms */, CONTENT_SETTING_ASK);
-}