Make all PermissionDecisionAutoBlocker methods static.

chrome/browser/permissions/permission_context_base.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 <stddef.h>
 #include <utility>
 
 #include "base/callback.h"
@@ skipping 30 matching lines @@
     "PermissionsKillSwitch";
 // static
 const char PermissionContextBase::kPermissionsKillSwitchBlockedValue[] =
     "blocked";
 
 PermissionContextBase::PermissionContextBase(
     Profile* profile,
     const content::PermissionType permission_type,
     const ContentSettingsType content_settings_type)
     : profile_(profile),
-      decision_auto_blocker_(new PermissionDecisionAutoBlocker(profile)),
       permission_type_(permission_type),
       content_settings_type_(content_settings_type),
       weak_factory_(this) {
 #if defined(OS_ANDROID)
   permission_queue_controller_.reset(new PermissionQueueController(
       profile_, permission_type_, content_settings_type_));
 #endif
+  PermissionDecisionAutoBlocker::UpdateFromVariations();

[kcarattini, 2016/10/04 05:26:05]

How often do you expect the value to change? You could alternatively call this
at the top of each of the  PermissionDecisionAutoBlocker static methods to
ensure they use the most up-to-date value. Might be overkill if that's not so
important.

[dominickn, 2016/10/04 06:18:54]

I think having it within PermissionContextBase makes the most amount of sense
overhead-wise. This shouldn't change all that often, but we need to call it more
often than browser startup for people who restart rarely.

[raymes, 2016/10/05 05:02:32]

This will only really happen once at browser (profile) startup. Maybe that's
good enough though.

[dominickn, 2016/10/05 05:55:30]

Acknowledged.

 }
 
 PermissionContextBase::~PermissionContextBase() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 }
 
 void PermissionContextBase::RequestPermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
@@ skipping 162 matching lines @@
                                         requesting_origin, profile_);
   } else {
     PermissionUmaUtil::PermissionDismissed(permission_type_, gesture_type,
                                            requesting_origin, profile_);
   }
 #endif
 
   // Check if we should convert a dismiss decision into a block decision. This
   // is gated on enabling the kBlockPromptsIfDismissedOften feature.
   if (content_setting == CONTENT_SETTING_DEFAULT &&
-      decision_auto_blocker_->ShouldChangeDismissalToBlock(requesting_origin,
-                                                           permission_type_)) {
+      PermissionDecisionAutoBlocker::ShouldChangeDismissalToBlock(
+          requesting_origin, permission_type_, profile_)) {
     persist = true;
     content_setting = CONTENT_SETTING_BLOCK;
   }
 
   NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                       persist, content_setting);
 }
 
 #if defined(OS_ANDROID)
 PermissionQueueController* PermissionContextBase::GetQueueController() {
@@ skipping 46 matching lines @@
                                       content_setting);
 }
 
 bool PermissionContextBase::IsPermissionKillSwitchOn() const {
   const std::string param = variations::GetVariationParamValue(
       kPermissionsKillSwitchFieldStudy,
       PermissionUtil::GetPermissionString(permission_type_));
 
   return param == kPermissionsKillSwitchBlockedValue;
 }