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 446 matching lines @@
       ContentSettingsType content_settings_type,
       scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> db_manager,
       const GURL& url,
       int timeout,
       ContentSetting response) {
     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));
+    if (response == CONTENT_SETTING_ALLOW) {

[raymes, 2017/01/23 06:14:23]

How come this changed? 

[meredithl, 2017/01/24 01:20:46]

Because when the permission isn't embargoed and automatically blocked, it needed
to be responded to other wise it would crash the test when destroying the
permission context, because it still had an outstanding request. This was a way
to only set the permission to be responded to if it needed to be, and test both
cases when the permission is embargoed and when it isn't.

[raymes, 2017/01/24 03:31:08]

I see. I think the confusing thing here is what |response| means. I would
suggest renaming it to expected_permission_status. We can add a comment above
this saying that we only set the repsonse callback if we don't expect the
permission to be blacklisted.

[meredithl, 2017/01/24 04:52:25]

Done.

+      permission_context.SetRespondPermissionCallback(
+          base::Bind(&PermissionContextBaseTests::RespondToPermission,
+                     base::Unretained(this), &permission_context, id, url,
+                     true /* persist */, response));
+    }
+
     permission_context.RequestPermission(
         web_contents(), id, url, true /* user_gesture */,
         base::Bind(&TestPermissionContext::TrackPermissionDecision,
                    base::Unretained(&permission_context)));
+    EXPECT_EQ(response, permission_context.GetPermissionStatus(url, url));
 
-    ASSERT_EQ(1u, permission_context.decisions().size());
-    EXPECT_EQ(response, permission_context.decisions()[0]);
+    if (response == CONTENT_SETTING_ALLOW) {
+      ASSERT_EQ(1u, permission_context.decisions().size());
+      EXPECT_EQ(response, 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 152 matching lines @@
   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, 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)};
   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);
-}