Make the PermissionDecisionAutoBlocker API consistent.

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/memory/ptr_util.h"
@@ skipping 150 matching lines @@
 // static
 const char PermissionDecisionAutoBlocker::kPermissionDismissalEmbargoKey[] =
     "dismissal_embargo_days";
 
 // static
 PermissionDecisionAutoBlocker* PermissionDecisionAutoBlocker::GetForProfile(
     Profile* profile) {
   return PermissionDecisionAutoBlocker::Factory::GetForProfile(profile);
 }
 
-PermissionDecisionAutoBlocker::PermissionDecisionAutoBlocker(Profile* profile)
-    : profile_(profile),
-      db_manager_(nullptr),
-      safe_browsing_timeout_(kCheckUrlTimeoutMs),
-      clock_(new base::DefaultClock()) {
-  safe_browsing::SafeBrowsingService* sb_service =
-      g_browser_process->safe_browsing_service();
-  if (sb_service)
-    db_manager_ = sb_service->database_manager();
-}
-
-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_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_PERMISSION_AUTOBLOCKER_DATA,
-          std::string(), nullptr);
-    }
-  }
-}
-
-int PermissionDecisionAutoBlocker::GetDismissCount(
-    const GURL& url,
-    ContentSettingsType permission) {
-  return GetActionCount(url, permission, kPromptDismissCountKey, profile_);
-}
-
-int PermissionDecisionAutoBlocker::GetIgnoreCount(
-    const GURL& url,
-    ContentSettingsType permission) {
-  return GetActionCount(url, permission, kPromptIgnoreCountKey, profile_);
-}
-
-bool PermissionDecisionAutoBlocker::RecordDismissAndEmbargo(
-    const GURL& url,
-    ContentSettingsType permission) {
-  int current_dismissal_count = RecordActionInWebsiteSettings(
-      url, permission, kPromptDismissCountKey, profile_);
-
-  if (base::FeatureList::IsEnabled(features::kBlockPromptsIfDismissedOften) &&
-      current_dismissal_count >= g_prompt_dismissals_before_block) {
-    PlaceUnderEmbargo(permission, url, kPermissionDismissalEmbargoKey);
-    return true;
-  }
-  return false;
-}
-
-int PermissionDecisionAutoBlocker::RecordIgnore(
-    const GURL& url,
-    ContentSettingsType permission) {
-  return RecordActionInWebsiteSettings(url, permission, kPromptIgnoreCountKey,
-                                       profile_);
-}
-
 // static
 void PermissionDecisionAutoBlocker::UpdateFromVariations() {
   int prompt_dismissals = -1;
   int blacklist_embargo_days = -1;
   int dismissal_embargo_days = -1;
   std::string dismissals_value = variations::GetVariationParamValueByFeature(
       features::kBlockPromptsIfDismissedOften, kPromptDismissCountKey);
   std::string blacklist_embargo_value =
       variations::GetVariationParamValueByFeature(
           features::kPermissionsBlacklist, kPermissionBlacklistEmbargoKey);
   std::string dismissal_embargo_value =
       variations::GetVariationParamValueByFeature(
           features::kBlockPromptsIfDismissedOften,
           kPermissionDismissalEmbargoKey);
   // If converting the value fails, stick with the current value.
   if (base::StringToInt(dismissals_value, &prompt_dismissals) &&
       prompt_dismissals > 0) {
     g_prompt_dismissals_before_block = prompt_dismissals;
   }
   if (base::StringToInt(blacklist_embargo_value, &blacklist_embargo_days) &&
       blacklist_embargo_days > 0) {
     g_blacklist_embargo_days = blacklist_embargo_days;
   }
   if (base::StringToInt(dismissal_embargo_value, &dismissal_embargo_days) &&
       dismissal_embargo_days > 0) {
     g_dismissal_embargo_days = dismissal_embargo_days;
   }
 }
 
-void PermissionDecisionAutoBlocker::UpdateEmbargoedStatus(
+void PermissionDecisionAutoBlocker::CheckSafeBrowsingBlacklist(
+    content::WebContents* web_contents,
+    const GURL& request_origin,
     ContentSettingsType permission,
-    const GURL& request_origin,
-    content::WebContents* web_contents,
     base::Callback<void(bool)> callback) {
   DCHECK_EQ(CONTENT_SETTING_ASK,
-            GetEmbargoResult(permission, request_origin).content_setting);
+            GetEmbargoResult(request_origin, permission).content_setting);
 
   if (base::FeatureList::IsEnabled(features::kPermissionsBlacklist) &&
       db_manager_) {
     // The CheckSafeBrowsingResult callback won't be called if the profile is
     // destroyed before a result is received. In that case this object will have
     // been destroyed by that point.
     PermissionBlacklistClient::CheckSafeBrowsingBlacklist(
-        db_manager_, permission, request_origin, web_contents,
+        web_contents, db_manager_, request_origin, permission,
         safe_browsing_timeout_,
         base::Bind(&PermissionDecisionAutoBlocker::CheckSafeBrowsingResult,
-                   base::Unretained(this), permission, request_origin,
+                   base::Unretained(this), request_origin, permission,
                    callback));
     return;
   }
 
   callback.Run(false /* permission blocked */);
 }
 
 PermissionResult PermissionDecisionAutoBlocker::GetEmbargoResult(
-    ContentSettingsType permission,
-    const GURL& request_origin) {
+    const GURL& request_origin,
+    ContentSettingsType permission) {
   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));
   double embargo_date = -1;
 
   base::Time current_time = clock_->Now();
   if (base::FeatureList::IsEnabled(features::kPermissionsBlacklist) &&
@@ skipping 15 matching lines @@
             base::TimeDelta::FromDays(g_dismissal_embargo_days)) {
       return PermissionResult(CONTENT_SETTING_BLOCK,
                               PermissionStatusSource::MULTIPLE_DISMISSALS);
     }
   }
 
   return PermissionResult(CONTENT_SETTING_ASK,
                           PermissionStatusSource::UNSPECIFIED);
 }
 
+int PermissionDecisionAutoBlocker::GetDismissCount(
+    const GURL& url,
+    ContentSettingsType permission) {
+  return GetActionCount(url, permission, kPromptDismissCountKey, profile_);
+}
+
+int PermissionDecisionAutoBlocker::GetIgnoreCount(
+    const GURL& url,
+    ContentSettingsType permission) {
+  return GetActionCount(url, permission, kPromptIgnoreCountKey, profile_);
+}
+
+bool PermissionDecisionAutoBlocker::RecordDismissAndEmbargo(
+    const GURL& url,
+    ContentSettingsType permission) {
+  int current_dismissal_count = RecordActionInWebsiteSettings(
+      url, permission, kPromptDismissCountKey, profile_);
+
+  if (base::FeatureList::IsEnabled(features::kBlockPromptsIfDismissedOften) &&
+      current_dismissal_count >= g_prompt_dismissals_before_block) {
+    PlaceUnderEmbargo(url, permission, kPermissionDismissalEmbargoKey);
+    return true;
+  }
+  return false;
+}
+
+int PermissionDecisionAutoBlocker::RecordIgnore(
+    const GURL& url,
+    ContentSettingsType permission) {
+  return RecordActionInWebsiteSettings(url, permission, kPromptIgnoreCountKey,
+                                       profile_);
+}
+
+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_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_PERMISSION_AUTOBLOCKER_DATA,
+          std::string(), nullptr);
+    }
+  }
+}
+
+PermissionDecisionAutoBlocker::PermissionDecisionAutoBlocker(Profile* profile)
+    : profile_(profile),
+      db_manager_(nullptr),
+      safe_browsing_timeout_(kCheckUrlTimeoutMs),
+      clock_(new base::DefaultClock()) {
+  safe_browsing::SafeBrowsingService* sb_service =
+      g_browser_process->safe_browsing_service();
+  if (sb_service)
+    db_manager_ = sb_service->database_manager();
+}
+
+PermissionDecisionAutoBlocker::~PermissionDecisionAutoBlocker() {}
+
 void PermissionDecisionAutoBlocker::CheckSafeBrowsingResult(
+    const GURL& request_origin,
     ContentSettingsType 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,
+    PlaceUnderEmbargo(request_origin, permission,
                       kPermissionBlacklistEmbargoKey);
   }
   callback.Run(should_be_embargoed /* permission blocked */);
 }
 
 void PermissionDecisionAutoBlocker::PlaceUnderEmbargo(
+    const GURL& request_origin,
     ContentSettingsType 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_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);
 }