Change MediaPermission not to use PermissionContext directly

chrome/browser/permissions/permission_manager.cc

 // Copyright 2015 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_manager.h"
 
 #include <stddef.h>
 
 #include <memory>
 #include <utility>
@@ skipping 138 matching lines @@
 ContentSetting GetContentSettingForConstantPermission(PermissionType type) {
   DCHECK(IsConstantPermission(type));
   switch (type) {
     case PermissionType::MIDI:
       return CONTENT_SETTING_ALLOW;
     default:
       return CONTENT_SETTING_DEFAULT;
   }
 }
 
-PermissionStatus GetPermissionStatusForConstantPermission(PermissionType type) {
-  return ContentSettingToPermissionStatus(
-      GetContentSettingForConstantPermission(type));
-}
-
 }  // anonymous namespace
 
 class PermissionManager::PendingRequest {
  public:
   PendingRequest(content::RenderFrameHost* render_frame_host,
                  const std::vector<PermissionType> permissions,
                  const base::Callback<
                      void(const std::vector<PermissionStatus>&)>& callback)
       : render_process_id_(render_frame_host->GetProcess()->GetID()),
         render_frame_id_(render_frame_host->GetRoutingID()),
@@ skipping 213 matching lines @@
 
   context->ResetPermission(requesting_origin.GetOrigin(),
                            embedding_origin.GetOrigin());
 }
 
 PermissionStatus PermissionManager::GetPermissionStatus(
     PermissionType permission,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (IsConstantPermission(permission))
-    return GetPermissionStatusForConstantPermission(permission);
-
-  PermissionContextBase* context = GetPermissionContext(permission);
-  if (!context)
-    return PermissionStatus::DENIED;
-
-  return ContentSettingToPermissionStatus(context->GetPermissionStatus(
-      requesting_origin.GetOrigin(), embedding_origin.GetOrigin()));
+  return ContentSettingToPermissionStatus(GetPermissionStatusInternal(
+      permission, requesting_origin, embedding_origin));
 }
 
 void PermissionManager::RegisterPermissionUsage(PermissionType permission,
                                                 const GURL& requesting_origin,
                                                 const GURL& embedding_origin) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // This is required because constant permissions don't have a
   // ContentSettingsType.
   if (IsConstantPermission(permission))
     return;
@@ skipping 12 matching lines @@
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (subscriptions_.IsEmpty())
     HostContentSettingsMapFactory::GetForProfile(profile_)->AddObserver(this);
 
   auto subscription = base::MakeUnique<Subscription>();
   subscription->permission = permission;
   subscription->requesting_origin = requesting_origin;
   subscription->embedding_origin = embedding_origin;
   subscription->callback = callback;
 
-  if (IsConstantPermission(permission)) {
-    subscription->current_value = GetContentSettingForConstantPermission(
-        permission);
-  } else {
-    subscription->current_value =
-        GetPermissionContext(permission)
-            ->GetPermissionStatus(subscription->requesting_origin,
-                                  subscription->embedding_origin);
-  }
+  subscription->current_value = GetPermissionStatusInternal(
+      permission, requesting_origin, embedding_origin);
 
   return subscriptions_.Add(std::move(subscription));
 }
 
 void PermissionManager::UnsubscribePermissionStatusChange(int subscription_id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   // Whether |subscription_id| is known will be checked by the Remove() call.
   subscriptions_.Remove(subscription_id);
 
   if (subscriptions_.IsEmpty())
     HostContentSettingsMapFactory::GetForProfile(profile_)
         ->RemoveObserver(this);
 }
 
+bool PermissionManager::IsPermissionKillSwitchOn(
+    content::PermissionType permission) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return GetPermissionContext(permission)->IsPermissionKillSwitchOn();
+}
+
 void PermissionManager::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   std::list<base::Closure> callbacks;
 
   for (SubscriptionsMap::iterator iter(&subscriptions_);
        !iter.IsAtEnd(); iter.Advance()) {
     Subscription* subscription = iter.GetCurrentValue();
     if (IsConstantPermission(subscription->permission))
       continue;
     if (PermissionTypeToContentSetting(subscription->permission) !=
         content_type) {
       continue;
     }
 
     if (primary_pattern.IsValid() &&
         !primary_pattern.Matches(subscription->requesting_origin))
       continue;
     if (secondary_pattern.IsValid() &&
         !secondary_pattern.Matches(subscription->embedding_origin))
       continue;
 
-    ContentSetting new_value =
-        GetPermissionContext(subscription->permission)
-            ->GetPermissionStatus(subscription->requesting_origin,
-                                  subscription->embedding_origin);
+    ContentSetting new_value = GetPermissionStatusInternal(
+        subscription->permission, subscription->requesting_origin,
+        subscription->embedding_origin);
     if (subscription->current_value == new_value)
       continue;
 
     subscription->current_value = new_value;
 
     // Add the callback to |callbacks| which will be run after the loop to
     // prevent re-entrance issues.
     callbacks.push_back(
         base::Bind(subscription->callback,
                    ContentSettingToPermissionStatus(new_value)));
   }
 
   for (const auto& callback : callbacks)
     callback.Run();
 }
+
+ContentSetting PermissionManager::GetPermissionStatusInternal(
+    PermissionType permission,
+    const GURL& requesting_origin,
+    const GURL& embedding_origin) {
+  if (IsConstantPermission(permission))
+    return GetContentSettingForConstantPermission(permission);
+
+  PermissionContextBase* context = GetPermissionContext(permission);
+  return context->GetPermissionStatus(requesting_origin.GetOrigin(),
+                                      embedding_origin.GetOrigin());
+}