Migrate content setting PROMPT_NO_DECISION_COUNT to PERMISSION_AUTOBLOCKER_DATA

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 <memory>
 
 #include "base/feature_list.h"
 #include "base/logging.h"
@@ skipping 29 matching lines @@
 // The number of days that an origin will stay under embargo for a requested
 // permission due to repeated dismissals.
 int g_dismissal_embargo_days = 7;
 
 // Maximum time in milliseconds to wait for safe browsing service to check a
 // url for blacklisting. After this amount of time, the check will be aborted
 // and the url will be treated as not safe.
 // TODO(meredithl): Revisit this once UMA metrics have data about request time.
 const int kCheckUrlTimeoutMs = 2000;
 
-// TODO(meredithl): Migrate to a new and more fitting type, once metrics have
-// been gathered, and deprecate CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT.
 std::unique_ptr<base::DictionaryValue> GetOriginDict(
     HostContentSettingsMap* settings,
     const GURL& origin_url) {
   std::unique_ptr<base::DictionaryValue> dict =
       base::DictionaryValue::From(settings->GetWebsiteSetting(
-          origin_url, GURL(), CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT,
+          origin_url, GURL(), CONTENT_SETTINGS_TYPE_PERMISSION_AUTOBLOCKER_DATA,
           std::string(), nullptr));
   if (!dict)
     return base::MakeUnique<base::DictionaryValue>();
 
   return dict;
 }
 
 base::DictionaryValue* GetOrCreatePermissionDict(
     base::DictionaryValue* origin_dict,
     const std::string& permission) {
@@ skipping 17 matching lines @@
   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);
   permission_dict->SetInteger(key, ++current_count);
 
   map->SetWebsiteSettingDefaultScope(
-      url, GURL(), CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT,
+      url, GURL(), CONTENT_SETTINGS_TYPE_PERMISSION_AUTOBLOCKER_DATA,
       std::string(), std::move(dict));
 
   return current_count;
 }
 
 int GetActionCount(const GURL& url,
                    content::PermissionType permission,
                    const char* key,
                    Profile* profile) {
   HostContentSettingsMap* map =
@@ skipping 80 matching lines @@
 
 PermissionDecisionAutoBlocker::~PermissionDecisionAutoBlocker() {}
 
 void PermissionDecisionAutoBlocker::RemoveCountsByUrl(
     base::Callback<bool(const GURL& url)> filter) {
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
 
   std::unique_ptr<ContentSettingsForOneType> settings(
       new ContentSettingsForOneType);
-  map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT,
+  map->GetSettingsForOneType(CONTENT_SETTINGS_TYPE_PERMISSION_AUTOBLOCKER_DATA,
                              std::string(), settings.get());
 
   for (const auto& site : *settings) {
     GURL origin(site.primary_pattern.ToString());
 
     if (origin.is_valid() && filter.Run(origin)) {
       map->SetWebsiteSettingDefaultScope(
-          origin, GURL(), CONTENT_SETTINGS_TYPE_PROMPT_NO_DECISION_COUNT,
+          origin, GURL(), CONTENT_SETTINGS_TYPE_PERMISSION_AUTOBLOCKER_DATA,
           std::string(), nullptr);
     }
   }
 }
 
 int PermissionDecisionAutoBlocker::GetDismissCount(
     const GURL& url,
     content::PermissionType permission) {
   return GetActionCount(url, permission, kPromptDismissCountKey, profile_);
 }
@@ skipping 112 matching lines @@
         base::Time::FromInternalValue(embargo_date) +
             base::TimeDelta::FromDays(g_dismissal_embargo_days)) {
       is_under_dismiss_embargo = true;
     }
   }
 
   // If either embargo is still in effect, return true.
   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.
     PlaceUnderEmbargo(permission, request_origin,
                       kPermissionBlacklistEmbargoKey);
   }
   callback.Run(should_be_embargoed /* permission blocked */);
 }
 
-// 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,
+      request_origin, GURL(), CONTENT_SETTINGS_TYPE_PERMISSION_AUTOBLOCKER_DATA,
       std::string(), std::move(dict));
 }
 
 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);
 }