Permissions: Allow PermissionManager to return more PermissionStatusSources.

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 117 matching lines @@
   // 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.
   // TODO(raymes): Pass in the RenderFrameHost of the request here.
   PermissionResult result = GetPermissionStatus(
       nullptr /* render_frame_host */, requesting_origin, embedding_origin);
 
   if (result.content_setting == CONTENT_SETTING_ALLOW ||
       result.content_setting == CONTENT_SETTING_BLOCK) {
     switch (result.source) {
+      case PermissionStatusSource::SAFE_BROWSING_BLACKLIST:
+        LogPermissionBlockedMessage(web_contents,
+                                    kPermissionBlockedBlacklistMessage,
+                                    content_settings_type_);
+        break;
       case PermissionStatusSource::KILL_SWITCH:
         // Block the request and log to the developer console.
         LogPermissionBlockedMessage(web_contents,
                                     kPermissionBlockedKillSwitchMessage,
                                     content_settings_type_);
         callback.Run(CONTENT_SETTING_BLOCK);
         return;
       case PermissionStatusSource::MULTIPLE_DISMISSALS:
         LogPermissionBlockedMessage(web_contents,
                                     kPermissionBlockedRepeatedDismissalsMessage,
                                     content_settings_type_);
         break;
       case PermissionStatusSource::MULTIPLE_IGNORES:
         LogPermissionBlockedMessage(web_contents,
                                     kPermissionBlockedRepeatedIgnoresMessage,
                                     content_settings_type_);
         break;
-      case PermissionStatusSource::SAFE_BROWSING_BLACKLIST:
-        LogPermissionBlockedMessage(web_contents,
-                                    kPermissionBlockedBlacklistMessage,
-                                    content_settings_type_);
-        break;
       case PermissionStatusSource::UNSPECIFIED:
+      case PermissionStatusSource::INSECURE_ORIGIN:
+      case PermissionStatusSource::ENTERPRISE_POLICY:
+      case PermissionStatusSource::EXTENSION:
         break;
     }
 
     // If we are under embargo, record the embargo reason for which we have
     // suppressed the prompt.
     PermissionUmaUtil::RecordEmbargoPromptSuppressionFromSource(result.source);
     NotifyPermissionSet(id, requesting_origin, embedding_origin, callback,
                         false /* persist */, result.content_setting);
     return;
   }
@@ skipping 54 matching lines @@
     const GURL& embedding_origin) const {
   // If the permission has been disabled through Finch, block all requests.
   if (IsPermissionKillSwitchOn()) {
     return PermissionResult(CONTENT_SETTING_BLOCK,
                             PermissionStatusSource::KILL_SWITCH);
   }
 
   if (IsRestrictedToSecureOrigins()) {
     if (!content::IsOriginSecure(requesting_origin)) {
       return PermissionResult(CONTENT_SETTING_BLOCK,
-                              PermissionStatusSource::UNSPECIFIED);
+                              PermissionStatusSource::INSECURE_ORIGIN);
     }
 
     // TODO(raymes): We should check the entire chain of embedders here whenever
     // possible as this corresponds to the requirements of the secure contexts
     // spec and matches what is implemented in blink. Right now we just check
     // the top level and requesting origins. Note: chrome-extension:// origins
     // are currently exempt from checking the embedder chain. crbug.com/530507.
     if (!requesting_origin.SchemeIs(extensions::kExtensionScheme) &&
         !content::IsOriginSecure(embedding_origin)) {
       return PermissionResult(CONTENT_SETTING_BLOCK,
-                              PermissionStatusSource::UNSPECIFIED);
+                              PermissionStatusSource::INSECURE_ORIGIN);
     }
   }
 
   // Check whether the feature is enabled for the frame by feature policy. We
   // can only do this when a RenderFrameHost has been provided.
   if (render_frame_host &&
       !PermissionAllowedByFeaturePolicy(render_frame_host)) {
     return PermissionResult(CONTENT_SETTING_BLOCK,
                             PermissionStatusSource::UNSPECIFIED);
   }
 
-  ContentSetting content_setting = GetPermissionStatusInternal(
+  PermissionResult result = GetPermissionStatusInternal(
       render_frame_host, requesting_origin, embedding_origin);
-  if (content_setting == CONTENT_SETTING_ASK) {
-    PermissionResult result =
-        PermissionDecisionAutoBlocker::GetForProfile(profile_)
-            ->GetEmbargoResult(requesting_origin, content_settings_type_);
+  if (result.content_setting == CONTENT_SETTING_ASK) {
+    result = PermissionDecisionAutoBlocker::GetForProfile(profile_)
+                 ->GetEmbargoResult(requesting_origin, content_settings_type_);
     DCHECK(result.content_setting == CONTENT_SETTING_ASK ||
            result.content_setting == CONTENT_SETTING_BLOCK);
-    return result;
   }
-
-  return PermissionResult(content_setting, PermissionStatusSource::UNSPECIFIED);
+  return result;
 }
 
 PermissionResult PermissionContextBase::UpdatePermissionStatusWithDeviceStatus(
     PermissionResult result,
     const GURL& requesting_origin,
     const GURL& embedding_origin) const {
   return result;
 }
 
 void PermissionContextBase::ResetPermission(const GURL& requesting_origin,
@@ skipping 26 matching lines @@
 }
 
 bool PermissionContextBase::IsPermissionKillSwitchOn() const {
   const std::string param = variations::GetVariationParamValue(
       kPermissionsKillSwitchFieldStudy,
       PermissionUtil::GetPermissionString(content_settings_type_));
 
   return param == kPermissionsKillSwitchBlockedValue;
 }
 
-ContentSetting PermissionContextBase::GetPermissionStatusInternal(
+PermissionResult PermissionContextBase::GetPermissionStatusInternal(
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     const GURL& embedding_origin) const {
-  return HostContentSettingsMapFactory::GetForProfile(profile_)
-      ->GetContentSetting(requesting_origin, embedding_origin,
-                          content_settings_storage_type(), std::string());
+  content_settings::SettingInfo info;
+  std::unique_ptr<base::Value> value =
+      HostContentSettingsMapFactory::GetForProfile(profile_)->GetWebsiteSetting(
+          requesting_origin, embedding_origin, content_settings_storage_type(),
+          std::string(), &info);
+  ContentSetting content_setting = CONTENT_SETTING_DEFAULT;
+  DCHECK(value.get());
+  DCHECK_EQ(base::Value::Type::INTEGER, value->GetType());
+  content_setting = content_settings::ValueToContentSetting(value.get());
+  return PermissionResult(
+      content_setting,
+      PermissionUtil::ConvertSettingSourceToPermissionStatusSource(
+          info.source));
 }
 
 void PermissionContextBase::DecidePermission(
     content::WebContents* web_contents,
     const PermissionRequestID& id,
     const GURL& requesting_origin,
     const GURL& embedding_origin,
     bool user_gesture,
     const BrowserPermissionCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ skipping 149 matching lines @@
     // Default to ignoring the feature policy.
     return true;
   }
 
   // Some features don't have an associated feature policy yet. Allow those.
   if (feature_policy_feature_ == blink::WebFeaturePolicyFeature::kNotFound)
     return true;
 
   return rfh->IsFeatureEnabled(feature_policy_feature_);
 }