Implement permission embargo suppression metrics.

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 299 matching lines @@
     }
 
     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.EmbargoPromptSuppression",
+        PermissionEmbargoStatus::NOT_EMBARGOED, 1);
     histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                   PermissionEmbargoStatus::NOT_EMBARGOED, 1);
   }
 
   void DismissMultipleTimesAndExpectBlock(
       const GURL& url,
       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(),
                                                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(content_settings_type),
           i + 1);
       histograms.ExpectBucketCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount." +
               PermissionUtil::GetPermissionString(content_settings_type),
           i, 1);
+
+// On Android, repeatedly requesting and deciding permissions has the side
+// effect of overcounting any metrics recorded in the PermissionInfoBarDelegate
+// destructor. This is because we directly call
+// PermissionQueueController::OnPermissionSet without setting the action_taken
+// bit in PermissionInfoBarDelegate. When PermissionQueueController is deleted
+// all OS_ANDROID ifdefs in this test can be removed.
+#if !defined(OS_ANDROID)
       histograms.ExpectTotalCount("Permissions.AutoBlocker.EmbargoStatus",
                                   i + 1);
+#endif
+
+      PermissionResult result =
+          permission_context.GetPermissionStatus(url, url);
+
+      histograms.ExpectUniqueSample(
+          "Permissions.AutoBlocker.EmbargoPromptSuppression",
+          PermissionEmbargoStatus::NOT_EMBARGOED, i + 1);
       if (i < 2) {
+        EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
+        EXPECT_EQ(CONTENT_SETTING_ASK, result.content_setting);
+#if !defined(OS_ANDROID)
         histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                       PermissionEmbargoStatus::NOT_EMBARGOED,
                                       i + 1);
+#endif
       } else {
+        EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
+        EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
+#if !defined(OS_ANDROID)
         histograms.ExpectBucketCount(
             "Permissions.AutoBlocker.EmbargoStatus",
             PermissionEmbargoStatus::REPEATED_DISMISSALS, 1);
+#endif
       }
 
       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(), 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);
+    EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
+    histograms.ExpectBucketCount(
+        "Permissions.AutoBlocker.EmbargoPromptSuppression",
+        PermissionEmbargoStatus::REPEATED_DISMISSALS, 1);
   }
 
   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_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(
           web_contents(), id, url, true /* user_gesture */,
           base::Bind(&TestPermissionContext::TrackPermissionDecision,
                     base::Unretained(&permission_context)));
       histograms.ExpectTotalCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount.Geolocation",
           i + 1);
       histograms.ExpectBucketCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount.Geolocation", i, 1);
+      histograms.ExpectUniqueSample(
+          "Permissions.AutoBlocker.EmbargoPromptSuppression",
+          PermissionEmbargoStatus::NOT_EMBARGOED, i + 1);
+
+// On Android, repeatedly requesting and deciding permissions has the side
+// effect of overcounting any metrics recorded in the PermissionInfoBarDelegate
+// destructor. This is because we directly call
+// PermissionQueueController::OnPermissionSet without setting the action_taken
+// bit in PermissionInfoBarDelegate. When PermissionQueueController is deleted
+// all OS_ANDROID ifdefs in this test can be removed.
+#if !defined(OS_ANDROID)
       histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                     PermissionEmbargoStatus::NOT_EMBARGOED,
                                     i + 1);
+#endif
 
       ASSERT_EQ(1u, permission_context.decisions().size());
       EXPECT_EQ(CONTENT_SETTING_ASK, permission_context.decisions()[0]);
       EXPECT_TRUE(permission_context.tab_context_updated());
       EXPECT_EQ(CONTENT_SETTING_ASK,
                 permission_context.GetContentSettingFromMap(url, url));
     }
 
     // Flush the dismissal counts. Enable the block on too many dismissals
     // feature, which is disabled by default.
@@ skipping 45 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_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));
       permission_context.RequestPermission(
           web_contents(), id, url, true /* user_gesture */,
           base::Bind(&TestPermissionContext::TrackPermissionDecision,
                      base::Unretained(&permission_context)));
 
       EXPECT_EQ(1u, permission_context.decisions().size());
       ASSERT_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);
 
       histograms.ExpectTotalCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount.MidiSysEx", i + 1);
       histograms.ExpectBucketCount(
           "Permissions.Prompt.Dismissed.PriorDismissCount.MidiSysEx", i, 1);
+      histograms.ExpectUniqueSample(
+          "Permissions.AutoBlocker.EmbargoPromptSuppression",
+          PermissionEmbargoStatus::NOT_EMBARGOED, i + 1);
 
+// On Android, repeatedly requesting and deciding permissions has the side
+// effect of overcounting any metrics recorded in the PermissionInfoBarDelegate
+// destructor. This is because we directly call
+// PermissionQueueController::OnPermissionSet without setting the action_taken
+// bit in PermissionInfoBarDelegate. When PermissionQueueController is deleted
+// all OS_ANDROID ifdefs in this test can be removed.
+#if !defined(OS_ANDROID)
       histograms.ExpectTotalCount("Permissions.AutoBlocker.EmbargoStatus",
                                   i + 1);
+#endif
       if (i < 4) {
+        EXPECT_EQ(CONTENT_SETTING_ASK, result.content_setting);
+        EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
+#if !defined(OS_ANDROID)
         histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                       PermissionEmbargoStatus::NOT_EMBARGOED,
                                       i + 1);
+#endif
       } else {
+        EXPECT_EQ(CONTENT_SETTING_BLOCK, result.content_setting);
+        EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
+#if !defined(OS_ANDROID)
         histograms.ExpectBucketCount(
             "Permissions.AutoBlocker.EmbargoStatus",
             PermissionEmbargoStatus::REPEATED_DISMISSALS, 1);
+#endif
       }
     }
 
     // Ensure that we finish in the block state.
     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);
-
+    EXPECT_EQ(PermissionStatusSource::MULTIPLE_DISMISSALS, result.source);
     variations::testing::ClearAllVariationParams();
   }
 
   void TestRequestPermissionInvalidUrl(
       ContentSettingsType content_settings_type) {
+    base::HistogramTester histograms;
     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));
+    histograms.ExpectTotalCount(
+        "Permissions.AutoBlocker.EmbargoPromptSuppression", 0);
   }
 
   void TestGrantAndRevoke_TestContent(ContentSettingsType content_settings_type,
                                       ContentSetting expected_default) {
     TestPermissionContext permission_context(profile(), content_settings_type);
     GURL url("https://www.google.com");
     NavigateAndCommit(url);
 
     const PermissionRequestID id(
         web_contents()->GetRenderProcessHost()->GetID(),
@@ skipping 101 matching lines @@
     scoped_feature_list.InitAndEnableFeature(features::kPermissionsBlacklist);
     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.
+    // expect the permission to be blacklisted.
     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)));
     PermissionResult result = permission_context.GetPermissionStatus(url, url);
     EXPECT_EQ(expected_permission_status, result.content_setting);
-    EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
 
     if (expected_permission_status == CONTENT_SETTING_ALLOW) {
       ASSERT_EQ(1u, permission_context.decisions().size());
       EXPECT_EQ(expected_permission_status, permission_context.decisions()[0]);
+      EXPECT_EQ(PermissionStatusSource::UNSPECIFIED, result.source);
+    } else {
+      EXPECT_EQ(PermissionStatusSource::SAFE_BROWSING_BLACKLIST, result.source);
     }
+    histograms.ExpectUniqueSample(
+        "Permissions.AutoBlocker.EmbargoPromptSuppression",
+        expected_embargo_reason, 1);
     histograms.ExpectUniqueSample("Permissions.AutoBlocker.EmbargoStatus",
                                   expected_embargo_reason, 1);
   }
 
  private:
   // ChromeRenderViewHostTestHarness:
   void SetUp() override {
     ChromeRenderViewHostTestHarness::SetUp();
 #if defined(OS_ANDROID)
     InfoBarService::CreateForWebContents(web_contents());
@@ skipping 138 matching lines @@
 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_SETTINGS_TYPE_NOTIFICATIONS, db_manager,
                               url, 2000 /* timeout */, CONTENT_SETTING_ALLOW,
                               PermissionEmbargoStatus::NOT_EMBARGOED);
 }