Add a PermissionContext subclass for the midi permission

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 <memory>
 #include <utility>
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/background_sync/background_sync_permission_context.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/media/midi_permission_context.h"
+#include "chrome/browser/media/midi_sysex_permission_context.h"
 #include "chrome/browser/media/webrtc/media_stream_device_permission_context.h"
 #include "chrome/browser/notifications/notification_permission_context.h"
 #include "chrome/browser/permissions/permission_context_base.h"
 #include "chrome/browser/permissions/permission_manager_factory.h"
 #include "chrome/browser/permissions/permission_request_id.h"
 #include "chrome/browser/permissions/permission_result.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/storage/durable_storage_permission_context.h"
 #include "chrome/browser/tab_contents/tab_util.h"
@@ skipping 78 matching lines @@
     case PermissionType::NUM:
       // This will hit the NOTREACHED below.
       break;
   }
 
   NOTREACHED() << "Unknown content setting for permission "
                << static_cast<int>(permission);
   return CONTENT_SETTINGS_TYPE_DEFAULT;
 }
 
-// Returns whether the permission has a constant ContentSetting value (i.e.
-// always approved or always denied)
-// The ContentSettingsTypes for which true is returned will also return nullptr
-// in PermissionManager::GetPermissionContext since they don't have a context.
-bool IsConstantPermission(ContentSettingsType type) {
-  return type == CONTENT_SETTINGS_TYPE_MIDI;
-}
-
 void SubscriptionCallbackWrapper(
     const base::Callback<void(PermissionStatus)>& callback,
     ContentSetting content_setting) {
   callback.Run(ContentSettingToPermissionStatus(content_setting));
 }
 
 void PermissionStatusCallbackWrapper(
     const base::Callback<void(PermissionStatus)>& callback,
     const std::vector<ContentSetting>& vector) {
   DCHECK_EQ(1ul, vector.size());
@@ skipping 10 matching lines @@
   callback.Run(permission_statuses);
 }
 
 void ContentSettingCallbackWraper(
     const base::Callback<void(ContentSetting)>& callback,
     const std::vector<ContentSetting>& vector) {
   DCHECK_EQ(1ul, vector.size());
   callback.Run(vector[0]);
 }
 
-// Function used for handling permission types which do not change their
-// value i.e. they are always approved or always denied etc.
-// CONTENT_SETTING_DEFAULT is returned if the permission needs further handling.
-// This function should only be called when IsConstantPermission has returned
-// true for the PermissionType.
-ContentSetting GetContentSettingForConstantPermission(
-    ContentSettingsType type) {
-  DCHECK(IsConstantPermission(type));
-  switch (type) {
-    case CONTENT_SETTINGS_TYPE_MIDI:
-      return CONTENT_SETTING_ALLOW;
-    default:
-      return CONTENT_SETTING_BLOCK;
-  }
-}
-
 }  // anonymous namespace
 
 class PermissionManager::PendingRequest {
  public:
   PendingRequest(
       content::RenderFrameHost* render_frame_host,
       const std::vector<ContentSettingsType>& permissions,
       const base::Callback<void(const std::vector<ContentSetting>&)>& callback)
       : render_process_id_(render_frame_host->GetProcess()->GetID()),
         render_frame_id_(render_frame_host->GetRoutingID()),
@@ skipping 46 matching lines @@
 
 // static
 PermissionManager* PermissionManager::Get(Profile* profile) {
   return PermissionManagerFactory::GetForProfile(profile);
 }
 
 PermissionManager::PermissionManager(Profile* profile)
     : profile_(profile),
       weak_ptr_factory_(this) {
   permission_contexts_[CONTENT_SETTINGS_TYPE_MIDI_SYSEX] =
+      base::MakeUnique<MidiSysexPermissionContext>(profile);
+  permission_contexts_[CONTENT_SETTINGS_TYPE_MIDI] =
       base::MakeUnique<MidiPermissionContext>(profile);
   permission_contexts_[CONTENT_SETTINGS_TYPE_PUSH_MESSAGING] =
       base::MakeUnique<NotificationPermissionContext>(
           profile, CONTENT_SETTINGS_TYPE_PUSH_MESSAGING);
   permission_contexts_[CONTENT_SETTINGS_TYPE_NOTIFICATIONS] =
       base::MakeUnique<NotificationPermissionContext>(
           profile, CONTENT_SETTINGS_TYPE_NOTIFICATIONS);
 #if !defined(OS_ANDROID)
   permission_contexts_[CONTENT_SETTINGS_TYPE_GEOLOCATION] =
       base::MakeUnique<GeolocationPermissionContext>(profile);
@@ skipping 62 matching lines @@
   GURL embedding_origin = web_contents->GetLastCommittedURL().GetOrigin();
 
   int request_id = pending_requests_.Add(base::MakeUnique<PendingRequest>(
       render_frame_host, permissions, callback));
 
   const PermissionRequestID request(render_frame_host, request_id);
 
   for (size_t i = 0; i < permissions.size(); ++i) {
     const ContentSettingsType permission = permissions[i];
 
-    if (IsConstantPermission(permission) || !GetPermissionContext(permission)) {
-      // Track permission request usages even for constant permissions.
-      PermissionUmaUtil::PermissionRequested(permission, requesting_origin,
-                                             embedding_origin, profile_);
-      OnPermissionsRequestResponseStatus(
-          request_id, i, GetContentSettingForConstantPermission(permission));
-      continue;
-    }
-
     PermissionContextBase* context = GetPermissionContext(permission);
+    DCHECK(context);
     context->RequestPermission(
         web_contents, request, requesting_origin, user_gesture,
         base::Bind(&PermissionManager::OnPermissionsRequestResponseStatus,
                    weak_ptr_factory_.GetWeakPtr(), request_id, i));
   }
 
   // The request might have been resolved already.
   if (!pending_requests_.Lookup(request_id))
     return kNoPendingOperation;
 
@@ skipping 172 matching lines @@
     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 (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;
 
@@ skipping 14 matching lines @@
 
   for (const auto& callback : callbacks)
     callback.Run();
 }
 
 PermissionResult PermissionManager::GetPermissionStatusHelper(
     ContentSettingsType permission,
     content::RenderFrameHost* render_frame_host,
     const GURL& requesting_origin,
     const GURL& embedding_origin) {
-  if (IsConstantPermission(permission)) {
-    return PermissionResult(GetContentSettingForConstantPermission(permission),
-                            PermissionStatusSource::UNSPECIFIED);
-  }
   PermissionContextBase* context = GetPermissionContext(permission);
   PermissionResult result = context->GetPermissionStatus(
-      nullptr /* render_frame_host */, requesting_origin.GetOrigin(),
+      render_frame_host, requesting_origin.GetOrigin(),
       embedding_origin.GetOrigin());
   DCHECK(result.content_setting == CONTENT_SETTING_ALLOW ||
          result.content_setting == CONTENT_SETTING_ASK ||
          result.content_setting == CONTENT_SETTING_BLOCK);
   return result;
 }