Add a source to the result of PermissionContextBase::GetPermissionStatus

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 <string>
 #include <utility>
@@ skipping 32 matching lines @@
 #include "chrome/browser/permissions/permission_queue_controller.h"
 #endif
 
 // static
 const char PermissionContextBase::kPermissionsKillSwitchFieldStudy[] =
     "PermissionsKillSwitch";
 // static
 const char PermissionContextBase::kPermissionsKillSwitchBlockedValue[] =
     "blocked";
 
+PermissionResult::PermissionResult(ContentSetting cs,
+                                   PermissionStatusSource pss)
+    : content_setting(cs), source(pss) {}
+
+PermissionResult::~PermissionResult() {}
+
 PermissionContextBase::PermissionContextBase(
     Profile* profile,
     const content::PermissionType permission_type,
     const ContentSettingsType content_settings_type)
     : profile_(profile),
       permission_type_(permission_type),
       content_settings_type_(content_settings_type),
       weak_factory_(this) {
 #if defined(OS_ANDROID)
   permission_queue_controller_.reset(new PermissionQueueController(
@@ skipping 41 matching lines @@
              << embedding_origin << " (" << type_name
              << " is not supported in popups)";
     NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                         false /* persist */, CONTENT_SETTING_BLOCK);
     return;
   }
 
   // Synchronously check the content setting to see if the user has already made
   // a decision, or if the origin is under embargo. If so, respect that
   // decision.
-  ContentSetting content_setting =
+  PermissionResult result =
       GetPermissionStatus(requesting_origin, embedding_origin);
-  if (content_setting == CONTENT_SETTING_ALLOW) {
+  if (result.content_setting == CONTENT_SETTING_ALLOW) {
     HostContentSettingsMapFactory::GetForProfile(profile_)->UpdateLastUsage(
         requesting_origin, embedding_origin, content_settings_type_);
   }
 
-  if (content_setting == CONTENT_SETTING_ALLOW ||
-      content_setting == CONTENT_SETTING_BLOCK) {
+  if (result.content_setting == CONTENT_SETTING_ALLOW ||
+      result.content_setting == CONTENT_SETTING_BLOCK) {
     NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
-                        false /* persist */, content_setting);
+                        false /* persist */, result.content_setting);
     return;
   }
 
   // Asynchronously check whether the origin should be blocked from making this
   // permission request. It may be on the Safe Browsing API blacklist, or it may
   // have been dismissed too many times in a row. If the origin is allowed to
   // request, that request will be made to ContinueRequestPermission().
   PermissionDecisionAutoBlocker::GetForProfile(profile_)->UpdateEmbargoedStatus(
       permission_type_, requesting_origin, web_contents,
       base::Bind(&PermissionContextBase::ContinueRequestPermission,
@@ skipping 22 matching lines @@
     return;
   }
 
   PermissionUmaUtil::PermissionRequested(permission_type_, requesting_origin,
                                          embedding_origin, profile_);
 
   DecidePermission(web_contents, id, requesting_origin, embedding_origin,
                    user_gesture, callback);
 }
 
-ContentSetting PermissionContextBase::GetPermissionStatus(
+PermissionResult PermissionContextBase::GetPermissionStatus(
     const GURL& requesting_origin,
     const GURL& embedding_origin) const {
   // If the permission has been disabled through Finch, block all requests.
-  if (IsPermissionKillSwitchOn())
-    return CONTENT_SETTING_BLOCK;
+  if (IsPermissionKillSwitchOn()) {
+    return PermissionResult(CONTENT_SETTING_BLOCK,
+                            PermissionStatusSource::KILL_SWITCH);
+  }
 
   if (IsRestrictedToSecureOrigins() &&
       !content::IsOriginSecure(requesting_origin)) {
-    return CONTENT_SETTING_BLOCK;
+    return PermissionResult(CONTENT_SETTING_BLOCK,
+                            PermissionStatusSource::INSECURE_ORIGIN);
   }
 
   ContentSetting content_setting =
       GetPermissionStatusInternal(requesting_origin, embedding_origin);
   if (content_setting == CONTENT_SETTING_ASK &&
       PermissionDecisionAutoBlocker::GetForProfile(profile_)->IsUnderEmbargo(
           permission_type_, requesting_origin)) {
-    return CONTENT_SETTING_BLOCK;
+    // TODO(raymes): Return the appropriate reason here, determined by
+    // PermissionDecisionAutoBlocker.
+    return PermissionResult(CONTENT_SETTING_BLOCK,
+                            PermissionStatusSource::UNSPECIFIED);
   }
-  return content_setting;
+
+  // TODO(raymes): Return the appropriate reason here, determined by
+  // GetPermissionStatusInternal.
+  return PermissionResult(content_setting, PermissionStatusSource::UNSPECIFIED);
 }
 
 void PermissionContextBase::ResetPermission(
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   HostContentSettingsMapFactory::GetForProfile(profile_)
       ->SetContentSettingDefaultScope(requesting_origin, embedding_origin,
                                       content_settings_type_, std::string(),
                                       CONTENT_SETTING_DEFAULT);
 }
@@ skipping 170 matching lines @@
   DCHECK(content_setting == CONTENT_SETTING_ALLOW ||
          content_setting == CONTENT_SETTING_BLOCK);
   DCHECK(!requesting_origin.SchemeIsFile());
   DCHECK(!embedding_origin.SchemeIsFile());
 
   HostContentSettingsMapFactory::GetForProfile(profile_)
       ->SetContentSettingDefaultScope(requesting_origin, embedding_origin,
                                       content_settings_type_, std::string(),
                                       content_setting);
 }