Add UMA for autoblocking and embargoing.

chrome/browser/permissions/permission_decision_auto_blocker.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 <string.h>
+
 #include <memory>
 
 #include "base/feature_list.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/permissions/permission_blacklist_client.h"
+#include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/common/chrome_features.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "components/safe_browsing_db/database_manager.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/permission_type.h"
@@ skipping 79 matching lines @@
       HostContentSettingsMapFactory::GetForProfile(profile);
   std::unique_ptr<base::DictionaryValue> dict = GetOriginDict(map, url);
   base::DictionaryValue* permission_dict = GetOrCreatePermissionDict(
       dict.get(), PermissionUtil::GetPermissionString(permission));
 
   int current_count = 0;
   permission_dict->GetInteger(key, &current_count);
   return current_count;
 }
 
+// Returns true if |url| has been embargoed from requesting |permission| for the
+// reason corresponding to |key|.
+bool WasPreviouslyEmbargoed(Profile* profile,
+                            const GURL& url,
+                            content::PermissionType permission,
+                            const char* key) {
+  HostContentSettingsMap* map =
+      HostContentSettingsMapFactory::GetForProfile(profile);
+  std::unique_ptr<base::DictionaryValue> dict = GetOriginDict(map, url);
+  base::DictionaryValue* permission_dict = GetOrCreatePermissionDict(
+      dict.get(), PermissionUtil::GetPermissionString(permission));
+  return permission_dict->HasKey(key);
+}
+
 }  // namespace
 
 // PermissionDecisionAutoBlocker::Factory --------------------------------------
 
 // static
 PermissionDecisionAutoBlocker*
 PermissionDecisionAutoBlocker::Factory::GetForProfile(Profile* profile) {
   return static_cast<PermissionDecisionAutoBlocker*>(
       GetInstance()->GetServiceForBrowserContext(profile, true));
 }
@@ skipping 94 matching lines @@
 }
 
 bool PermissionDecisionAutoBlocker::RecordDismissAndEmbargo(
     const GURL& url,
     content::PermissionType permission) {
   int current_dismissal_count = RecordActionInWebsiteSettings(
       url, permission, kPromptDismissCountKey, profile_);
 
   if (base::FeatureList::IsEnabled(features::kBlockPromptsIfDismissedOften) &&
       current_dismissal_count >= g_prompt_dismissals_before_block) {
+    if (WasPreviouslyEmbargoed(profile_, url, permission,
+                               kPermissionDismissalEmbargoKey)) {
+      PermissionUmaUtil::RecordRepeatedEmbargo(
+          PermissionEmbargoReason::REPEATED_DISMISSALS);
+    }
+
     PlaceUnderEmbargo(permission, url, kPermissionDismissalEmbargoKey);
     return true;
   }
   return false;
 }
 
 int PermissionDecisionAutoBlocker::RecordIgnore(
     const GURL& url,
     content::PermissionType permission) {
   return RecordActionInWebsiteSettings(url, permission, kPromptIgnoreCountKey,
@@ skipping 94 matching lines @@
   return is_under_dismiss_embargo || is_under_blacklist_embargo;
 }
 
 // static
 void PermissionDecisionAutoBlocker::CheckSafeBrowsingResult(
     content::PermissionType permission,
     const GURL& request_origin,
     base::Callback<void(bool)> callback,
     bool should_be_embargoed) {
   if (should_be_embargoed) {
-    // Requesting site is blacklisted for this permission, update the content
-    // setting to place it under embargo.
+    if (WasPreviouslyEmbargoed(profile_, request_origin, permission,
+                               kPermissionBlacklistEmbargoKey)) {
+      PermissionUmaUtil::RecordRepeatedEmbargo(
+          PermissionEmbargoReason::PERMISSIONS_BLACKLISTING);
+    }
+
     PlaceUnderEmbargo(permission, request_origin,
                       kPermissionBlacklistEmbargoKey);
   }
-  callback.Run(should_be_embargoed /* permission blocked */);
+
+  callback.Run(should_be_embargoed);
 }
 
 // static
 void PermissionDecisionAutoBlocker::PlaceUnderEmbargo(
     content::PermissionType permission,
     const GURL& request_origin,
     const char* key) {
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
   std::unique_ptr<base::DictionaryValue> dict =
       GetOriginDict(map, request_origin);
   base::DictionaryValue* permission_dict = GetOrCreatePermissionDict(
       dict.get(), PermissionUtil::GetPermissionString(permission));
   permission_dict->SetDouble(key, clock_->Now().ToInternalValue());
   map->SetWebsiteSettingDefaultScope(
       request_origin, GURL(), CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT,
       std::string(), std::move(dict));
+  PermissionEmbargoReason embargo_reason =
+      PermissionEmbargoReason::PERMISSIONS_BLACKLISTING;
+  if (std::strcmp(key, kPermissionDismissalEmbargoKey) == 0)
+    embargo_reason = PermissionEmbargoReason::REPEATED_DISMISSALS;
+  PermissionUmaUtil::RecordPermissionEmbargoReason(embargo_reason);
 }
 
 void PermissionDecisionAutoBlocker::
     SetSafeBrowsingDatabaseManagerAndTimeoutForTesting(
         scoped_refptr<safe_browsing::SafeBrowsingDatabaseManager> db_manager,
         int timeout) {
   db_manager_ = db_manager;
   safe_browsing_timeout_ = timeout;
 }
 
 void PermissionDecisionAutoBlocker::SetClockForTesting(
     std::unique_ptr<base::Clock> clock) {
   clock_ = std::move(clock);
 }