Add metrics for Safe Browsing blacklist response.

chrome/browser/permissions/permission_decision_auto_blocker_unittest.cc

 // Copyright 2016 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_decision_auto_blocker.h"
 
 #include <map>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
+#include "base/test/histogram_tester.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/test/simple_test_clock.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
+#include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/common/chrome_features.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/safe_browsing_db/test_database_manager.h"
 #include "content/public/browser/permission_type.h"
 
 namespace {
 
@@ skipping 223 matching lines @@
                    url2, content::PermissionType::GEOLOCATION));
   EXPECT_EQ(0, autoblocker()->GetIgnoreCount(
                    url2, content::PermissionType::DURABLE_STORAGE));
   EXPECT_EQ(0, autoblocker()->GetIgnoreCount(
                    url2, content::PermissionType::MIDI_SYSEX));
 }
 
 // Test that an origin that has been blacklisted for a permission is embargoed.
 TEST_F(PermissionDecisionAutoBlockerUnitTest, TestUpdateEmbargoBlacklist) {
   GURL url("https://www.google.com");
+  base::HistogramTester histograms;
 
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
       new MockSafeBrowsingDatabaseManager(true /* perform_callback */);
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                      2000 /* timeout in ms */);
 
   UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
   EXPECT_TRUE(last_embargoed_status());
+  histograms.ExpectUniqueSample("Permissions.AutoBlocker.SafeBrowsingResponse",
+                                SafeBrowsingResponse::BLACKLISTED, 1);
 }
 
 // Check that IsUnderEmbargo returns the correct value when the embargo is set
 // and expires.
 TEST_F(PermissionDecisionAutoBlockerUnitTest, CheckEmbargoStatus) {
   GURL url("https://www.google.com");
   clock()->SetNow(base::Time::Now());
 
   PlaceUnderBlacklistEmbargo(content::PermissionType::GEOLOCATION, url);
   EXPECT_TRUE(
@@ skipping 28 matching lines @@
 }
 
 // Tests the alternating pattern of the block on multiple dismiss behaviour. On
 // N dismissals, the origin to be embargoed for the requested permission and
 // automatically blocked. Each time the embargo is lifted, the site gets another
 // chance to request the permission, but if it is again dismissed it is placed
 // under embargo again and its permission requests blocked.
 TEST_F(PermissionDecisionAutoBlockerUnitTest, TestDismissEmbargoBackoff) {
   GURL url("https://www.google.com");
   clock()->SetNow(base::Time::Now());
+  base::HistogramTester histograms;
 
   // Record some dismisses.
   EXPECT_FALSE(autoblocker()->RecordDismissAndEmbargo(
       url, content::PermissionType::GEOLOCATION));
   EXPECT_FALSE(autoblocker()->RecordDismissAndEmbargo(
       url, content::PermissionType::GEOLOCATION));
 
   // A request with < 3 prior dismisses should not be automatically blocked.
   EXPECT_FALSE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 
   // After the 3rd dismiss subsequent permission requests should be autoblocked.
   EXPECT_TRUE(autoblocker()->RecordDismissAndEmbargo(
       url, content::PermissionType::GEOLOCATION));
   EXPECT_TRUE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 
+  histograms.ExpectTotalCount("Permissions.AutoBlocker.SafeBrowsingResponse",
+                              0);
+  histograms.ExpectTotalCount(
+      "Permissions.AutoBlocker.SafeBrowsingResponseTime", 0);
   // Accelerate time forward, check that the embargo status is lifted and the
   // request won't be automatically blocked.
   clock()->Advance(base::TimeDelta::FromDays(8));
   EXPECT_FALSE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 
   // Record another dismiss, subsequent requests should be autoblocked again.
   EXPECT_TRUE(autoblocker()->RecordDismissAndEmbargo(
       url, content::PermissionType::GEOLOCATION));
   EXPECT_TRUE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 
   // Accelerate time again, check embargo is lifted and another permission
   // request is let through.
   clock()->Advance(base::TimeDelta::FromDays(8));
   EXPECT_FALSE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
+
+  // Record another dismiss, subsequent requests should be autoblocked again.
+  EXPECT_TRUE(autoblocker()->RecordDismissAndEmbargo(
+      url, content::PermissionType::GEOLOCATION));
+  EXPECT_TRUE(
+      autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
+  histograms.ExpectTotalCount("Permissions.AutoBlocker.SafeBrowsingResponse",
+                              0);
+  histograms.ExpectTotalCount(
+      "Permissions.AutoBlocker.SafeBrowsingResponseTime", 0);
 }
 
 // Test the logic for a combination of blacklisting and dismissal embargo.
 TEST_F(PermissionDecisionAutoBlockerUnitTest, TestExpiredBlacklistEmbargo) {
   GURL url("https://www.google.com");
   clock()->SetNow(base::Time::Now());
 
   // Place under blacklist embargo and check the status.
   PlaceUnderBlacklistEmbargo(content::PermissionType::GEOLOCATION, url);
   clock()->Advance(base::TimeDelta::FromDays(5));
@@ skipping 11 matching lines @@
   // Accelerate time to a point where the blacklist embargo should be expired
   // and check that dismissal embargo is still set.
   clock()->Advance(base::TimeDelta::FromDays(3));
   EXPECT_TRUE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 }
 
 TEST_F(PermissionDecisionAutoBlockerUnitTest, TestSafeBrowsingTimeout) {
   GURL url("https://www.google.com");
   clock()->SetNow(base::Time::Now());
+  base::HistogramTester histograms;
 
   scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
       new MockSafeBrowsingDatabaseManager(false /* perform_callback */);
   std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
   db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
   SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                      0 /* timeout in ms */);
 
   UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
   EXPECT_FALSE(last_embargoed_status());
   EXPECT_FALSE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
+  histograms.ExpectUniqueSample("Permissions.AutoBlocker.SafeBrowsingResponse",
+                                SafeBrowsingResponse::TIMEOUT, 1);
+  histograms.ExpectTotalCount(
+      "Permissions.AutoBlocker.SafeBrowsingResponseTime", 1);
   db_manager->SetPerformCallback(true);
   SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
                                                      2000 /* timeout in ms */);
 
   clock()->Advance(base::TimeDelta::FromDays(1));
   UpdateEmbargoedStatus(content::PermissionType::GEOLOCATION, url);
   EXPECT_TRUE(last_embargoed_status());
-
+  histograms.ExpectTotalCount("Permissions.AutoBlocker.SafeBrowsingResponse",
+                              2);
+  histograms.ExpectTotalCount(
+      "Permissions.AutoBlocker.SafeBrowsingResponseTime", 2);
+  histograms.ExpectBucketCount("Permissions.AutoBlocker.SafeBrowsingResponse",
+                               SafeBrowsingResponse::BLACKLISTED, 1);
   clock()->Advance(base::TimeDelta::FromDays(1));
   EXPECT_TRUE(
       autoblocker()->IsUnderEmbargo(content::PermissionType::GEOLOCATION, url));
 }
 
 // TODO(raymes): See crbug.com/681709. Remove after M60.
 TEST_F(PermissionDecisionAutoBlockerUnitTest,
        MigrateNoDecisionCountToPermissionAutoBlockerData) {
   GURL url("https://www.google.com");
   auto* map = HostContentSettingsMapFactory::GetForProfile(profile());
@@ skipping 56 matching lines @@
         profile()->GetPrefs(), false /* is_incognito_profile */,
         false /* is_guest_profile */));
     temp_map->ShutdownOnUIThread();
   }
 
   EXPECT_EQ(100, autoblocker()->GetDismissCount(
                      url, content::PermissionType::GEOLOCATION));
   EXPECT_EQ(50, autoblocker()->GetIgnoreCount(
                     url, content::PermissionType::GEOLOCATION));
 }
+
+TEST_F(PermissionDecisionAutoBlockerUnitTest, TestSafeBrowsingResponse) {

[raymes, 2017/02/08 02:08:00]

nit: maybe this should just be called TestRequestNotEmbargoed (or something
similar)

[meredithl, 2017/02/08 02:40:32]

Done. I've also moved it upwards to underneath TestUpdateEmbargoBlacklisted,
which is basically the reverse case of this so logically the tests make a bit
more sense. 

+  GURL url("https://www.google.com");
+  clock()->SetNow(base::Time::Now());
+  base::HistogramTester histograms;
+
+  scoped_refptr<MockSafeBrowsingDatabaseManager> db_manager =
+      new MockSafeBrowsingDatabaseManager(true /* perform_callback */);
+  std::set<std::string> blacklisted_permissions{"GEOLOCATION"};
+  db_manager->BlacklistUrlPermissions(url, blacklisted_permissions);
+  SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(db_manager,
+                                                     0 /* timeout in ms */);
+
+  UpdateEmbargoedStatus(content::PermissionType::NOTIFICATIONS, url);
+  EXPECT_FALSE(last_embargoed_status());
+  histograms.ExpectUniqueSample("Permissions.AutoBlocker.SafeBrowsingResponse",
+                                SafeBrowsingResponse::NOT_BLACKLISTED, 1);
+  histograms.ExpectTotalCount(
+      "Permissions.AutoBlocker.SafeBrowsingResponseTime", 1);
+}