Remove the MediaPermissionStatus helper class

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 188 matching lines @@
   // device id is non-empty, then the corresponding device list must not be
   // NULL.
   if (!device_id.empty() && !devices->FindById(device_id))
     return false;
 
   return true;
 }
 
 }  // namespace
 
-// Stores whether a permission has been requested or blocked during the course
-// of a permission request, as well as the denial reason
-class MediaStreamDevicesController::MediaPermissionStatus {
- public:
-  explicit MediaPermissionStatus(const content::MediaStreamRequest& request)
-      : audio_requested_(
-            ContentTypeIsRequested(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                                   request)),
-        video_requested_(
-            ContentTypeIsRequested(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                                   request)) {}
-
-  ~MediaPermissionStatus() {}
-
-  bool audio_requested() const { return audio_requested_; }
-  bool video_requested() const { return video_requested_; }
-
-  bool audio_blocked() const { return audio_blocked_; }
-  bool video_blocked() const { return video_blocked_; }
-
-  content::MediaStreamRequestResult denial_reason() const {
-    return denial_reason_;
-  }
-
-  void SetAudioBlocked(content::MediaStreamRequestResult denial_reason) {
-    DCHECK(audio_requested_);
-    audio_blocked_ = true;
-    denial_reason_ = denial_reason;
-  }
-
-  void SetVideoBlocked(content::MediaStreamRequestResult denial_reason) {
-    DCHECK(video_requested_);
-    video_blocked_ = true;
-    denial_reason_ = denial_reason;
-  }
-
- private:
-  bool audio_requested_ = false;
-  bool video_requested_ = false;
-  bool audio_blocked_ = false;
-  bool video_blocked_ = false;
-
-  content::MediaStreamRequestResult denial_reason_ = content::MEDIA_DEVICE_OK;
-};
-
 // Implementation of PermissionPromptDelegate which actually shows a permission
 // prompt.
 class MediaStreamDevicesController::PermissionPromptDelegateImpl
     : public internal::PermissionPromptDelegate {
  public:
   void ShowPrompt(
       bool user_gesture,
       content::WebContents* web_contents,
       std::unique_ptr<MediaStreamDevicesController> controller) override {
 #if defined(OS_ANDROID)
@@ skipping 143 matching lines @@
   content::WebContents* web_contents =
       content::WebContents::FromRenderFrameHost(
           content::RenderFrameHost::FromID(request.render_process_id,
                                            request.render_frame_id));
   if (request.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY) {
     MediaPermissionRequestLogger::LogRequest(
         web_contents, request.render_process_id, request.render_frame_id,
         content::IsOriginSecure(request.security_origin));
   }
 
-  MediaPermissionStatus initial_permission(request);
-  if (initial_permission.audio_requested() &&
-      !HasAvailableDevices(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                           request.requested_audio_device_id)) {
-    initial_permission.SetAudioBlocked(content::MEDIA_DEVICE_NO_HARDWARE);
-  }
-
-  if (initial_permission.video_requested() &&
-      !HasAvailableDevices(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                           request.requested_video_device_id)) {
-    initial_permission.SetVideoBlocked(content::MEDIA_DEVICE_NO_HARDWARE);
-  }
-
   std::unique_ptr<MediaStreamDevicesController> controller(
-      new MediaStreamDevicesController(web_contents, request, callback,
-                                       initial_permission));
+      new MediaStreamDevicesController(web_contents, request, callback));
   if (!controller->IsAskingForAudio() && !controller->IsAskingForVideo()) {
 #if defined(OS_ANDROID)
     // If either audio or video was previously allowed and Chrome no longer has
     // the necessary permissions, show a infobar to attempt to address this
     // mismatch.
     std::vector<ContentSettingsType> content_settings_types;
     if (controller->IsAllowedForAudio())
       content_settings_types.push_back(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
 
     if (controller->IsAllowedForVideo()) {
@@ skipping 11 matching lines @@
     return;
   }
 
   delegate->ShowPrompt(request.user_gesture, web_contents,
                        std::move(controller));
 }
 
 MediaStreamDevicesController::MediaStreamDevicesController(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
-    const content::MediaResponseCallback& callback,
-    const MediaPermissionStatus& initial_permission)
+    const content::MediaResponseCallback& callback)
     : web_contents_(web_contents), request_(request), callback_(callback) {
   profile_ = Profile::FromBrowserContext(web_contents->GetBrowserContext());
   content_settings_ = TabSpecificContentSettings::FromWebContents(web_contents);
 
-  content::MediaStreamRequestResult denial_reason =
-      initial_permission.denial_reason();
-  old_audio_setting_ =
-      GetContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC, request,
-                        initial_permission.audio_requested(),
-                        initial_permission.audio_blocked(), &denial_reason);
-  old_video_setting_ =
-      GetContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, request,
-                        initial_permission.video_requested(),
-                        initial_permission.video_blocked(), &denial_reason);
+  content::MediaStreamRequestResult denial_reason = content::MEDIA_DEVICE_OK;
+  old_audio_setting_ = GetContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+                                         request, &denial_reason);
+  old_video_setting_ = GetContentSetting(
+      CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, request, &denial_reason);
 
   // If either setting is ask, we show the infobar.
   if (old_audio_setting_ == CONTENT_SETTING_ASK ||
       old_video_setting_ == CONTENT_SETTING_ASK) {
     return;
   }
 
 #if defined(OS_ANDROID)
   std::vector<ContentSettingsType> content_settings_types;
   if (IsAllowedForAudio())
@@ skipping 217 matching lines @@
   }
 
   content_settings_->OnMediaStreamPermissionSet(
       request_.security_origin, microphone_camera_state, selected_audio_device,
       selected_video_device, requested_audio_device, requested_video_device);
 }
 
 ContentSetting MediaStreamDevicesController::GetContentSetting(
     ContentSettingsType content_type,
     const content::MediaStreamRequest& request,
-    bool was_requested,
-    bool was_initially_blocked,
     content::MediaStreamRequestResult* denial_reason) const {
   DCHECK(content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC ||
          content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
   DCHECK(!request_.security_origin.is_empty());
   DCHECK(content::IsOriginSecure(request_.security_origin) ||
          request_.request_type == content::MEDIA_OPEN_DEVICE_PEPPER_ONLY);
-  if (!was_requested) {
+  if (!ContentTypeIsRequested(content_type, request)) {
     // No denial reason set as it will have been previously set.
     return CONTENT_SETTING_DEFAULT;
   }
 
-  if (was_initially_blocked) {
-    // No denial reason set as it will have been previously set.
+  std::string device_id;
+  if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC)
+    device_id = request.requested_audio_device_id;
+  else
+    device_id = request.requested_video_device_id;
+  if (!HasAvailableDevices(content_type, device_id)) {
+    *denial_reason = content::MEDIA_DEVICE_NO_HARDWARE;
     return CONTENT_SETTING_BLOCK;
   }
 
   if (!IsUserAcceptAllowed(content_type)) {
     *denial_reason = content::MEDIA_DEVICE_PERMISSION_DENIED;
     return CONTENT_SETTING_BLOCK;
   }
 
   PermissionResult result =
       PermissionManager::Get(profile_)->GetPermissionStatus(
@@ skipping 42 matching lines @@
     }
   }
 
   // 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;
 }