Replace PermissionType in chrome/ with ContentSettingsType

chrome/browser/media/webrtc/media_stream_devices_controller.cc

 // Copyright (c) 2012 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/media/webrtc/media_stream_devices_controller.h"
 
 #include <map>
 #include <utility>
 
 #include "base/callback_helpers.h"
@@ skipping 38 matching lines @@
 #include "content/public/browser/android/content_view_core.h"
 #include "ui/android/window_android.h"
 #endif  // defined(OS_ANDROID)
 
 using content::BrowserThread;
 
 namespace {
 
 // Returns true if the given ContentSettingsType is being requested in
 // |request|.
-bool ContentTypeIsRequested(content::PermissionType type,
+bool ContentTypeIsRequested(ContentSettingsType type,
                             const content::MediaStreamRequest& request) {
   if (request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY)
     return true;
 
-  if (type == content::PermissionType::AUDIO_CAPTURE)
+  if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
     return request.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE;
 
-  if (type == content::PermissionType::VIDEO_CAPTURE)
+  if (type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA)
     return request.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE;
 
   return false;
 }
 
 using PermissionActionCallback =
-    base::Callback<void(content::PermissionType,
+    base::Callback<void(ContentSettingsType,
                         PermissionRequestGestureType,
                         const GURL&,
                         Profile*)>;
 
 void RecordSinglePermissionAction(const content::MediaStreamRequest& request,
-                                  content::PermissionType permission_type,
+                                  ContentSettingsType content_type,
                                   Profile* profile,
                                   PermissionActionCallback callback) {
-  if (ContentTypeIsRequested(permission_type, request)) {
+  if (ContentTypeIsRequested(content_type, request)) {
     // TODO(stefanocs): Pass the actual |gesture_type| once this file has been
     // refactored into PermissionContext.
-    callback.Run(permission_type, PermissionRequestGestureType::UNKNOWN,
+    callback.Run(content_type, PermissionRequestGestureType::UNKNOWN,
                  request.security_origin, profile);
   }
 }
 
 // Calls |action_function| for each permission requested by |request|.
 void RecordPermissionAction(const content::MediaStreamRequest& request,
                             Profile* profile,
                             PermissionActionCallback callback) {
-  RecordSinglePermissionAction(request, content::PermissionType::AUDIO_CAPTURE,
+  RecordSinglePermissionAction(request, CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
                                profile, callback);
-  RecordSinglePermissionAction(request, content::PermissionType::VIDEO_CAPTURE,
-                               profile, callback);
+  RecordSinglePermissionAction(
+      request, CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, profile, callback);
 }
 
 // This helper class helps to measure the number of media stream requests that
 // occur. It ensures that only one request will be recorded per navigation, per
 // frame. TODO(raymes): Remove this when https://crbug.com/526324 is fixed.
 class MediaPermissionRequestLogger : content::WebContentsObserver {
   // Map of <render process id, render frame id> ->
   // MediaPermissionRequestLogger.
   using RequestMap = std::map<std::pair<int, int>,
                               std::unique_ptr<MediaPermissionRequestLogger>>;
@@ skipping 139 matching lines @@
   if (!IsAskingForAudio())
     message_id = IDS_MEDIA_CAPTURE_VIDEO_ONLY;
   else if (!IsAskingForVideo())
     message_id = IDS_MEDIA_CAPTURE_AUDIO_ONLY;
   return l10n_util::GetStringFUTF16(
       message_id,
       url_formatter::FormatUrlForSecurityDisplay(
           GetOrigin(), url_formatter::SchemeDisplay::OMIT_CRYPTOGRAPHIC));
 }
 
-content::PermissionType
-MediaStreamDevicesController::GetPermissionTypeForContentSettingsType(
-    ContentSettingsType content_type) const {
-  DCHECK(content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
-         content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
-  content::PermissionType permission = content::PermissionType::NUM;
-  CHECK(PermissionUtil::GetPermissionType(content_type, &permission));
-  return permission;
-}
-
 void MediaStreamDevicesController::ForcePermissionDeniedTemporarily() {
   set_persist(false);
   // TODO(tsergeant): Determine whether it is appropriate to record permission
   // action metrics here, as this is a different sort of user action.
   RunCallback(CONTENT_SETTING_BLOCK,
               CONTENT_SETTING_BLOCK,
               content::MEDIA_DEVICE_PERMISSION_DENIED);
   set_persist(true);
 }
 
@@ skipping 282 matching lines @@
   if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
     requested_device_id = request.requested_audio_device_id;
   else if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA)
     requested_device_id = request.requested_video_device_id;
 
   if (!IsUserAcceptAllowed(content_type)) {
     *denial_reason = content::MEDIA_DEVICE_PERMISSION_DENIED;
     return CONTENT_SETTING_BLOCK;
   }
 
-  content::PermissionType permission_type =
-      GetPermissionTypeForContentSettingsType(content_type);
-  if (ContentTypeIsRequested(permission_type, request)) {
+  if (ContentTypeIsRequested(content_type, request)) {
     DCHECK(content::IsOriginSecure(request_.security_origin) ||
            request_.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY);
     MediaPermission permission(content_type, request.security_origin,
         web_contents_->GetLastCommittedURL().GetOrigin(), profile_);
     return permission.GetPermissionStatusWithDeviceRequired(requested_device_id,
                                                             denial_reason);
   }
   // Return the default content setting if the device is not requested.
   return CONTENT_SETTING_DEFAULT;
 }
@@ skipping 39 matching lines @@
   if (android_permission_blocked)
     return false;
 
   // Don't approve device requests if the tab was hidden.
   // TODO(qinmin): Add a test for this. http://crbug.com/396869.
   // TODO(raymes): Shouldn't this apply to all permissions not just audio/video?
   return web_contents_->GetRenderWidgetHostView()->IsShowing();
 #endif
   return true;
 }