Make media permission requests go through the PermissionManager

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"
+#include "base/feature_list.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/webrtc/media_stream_capture_indicator.h"
 #include "chrome/browser/media/webrtc/media_stream_device_permissions.h"
 #include "chrome/browser/permissions/permission_manager.h"
 #include "chrome/browser/permissions/permission_result.h"
 #include "chrome/browser/permissions/permission_uma_util.h"
 #include "chrome/browser/permissions/permission_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
-#include "chrome/common/chrome_switches.h"
+#include "chrome/common/chrome_features.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "components/content_settings/core/common/content_settings_pattern.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "components/url_formatter/elide_url.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
@@ skipping 343 matching lines @@
   }
 
   if (setting == CONTENT_SETTING_BLOCK)
     denial_reason_ = content::MEDIA_DEVICE_PERMISSION_DENIED;
   else if (setting == CONTENT_SETTING_ASK)
     denial_reason_ = content::MEDIA_DEVICE_PERMISSION_DISMISSED;
 
   RunCallback();
 }
 
+void MediaStreamDevicesController::PromptAnsweredGroupedRequest(
+    const std::vector<ContentSetting>& response) {
+  DCHECK(response.size() == 1 || response.size() == 2);
+
+  // The audio setting will always be the first one in the vector, if it was
+  // requested.
+  if (audio_setting_ == CONTENT_SETTING_ASK)
+    audio_setting_ = response.front();
+
+  if (video_setting_ == CONTENT_SETTING_ASK)
+    video_setting_ = response.back();
+
+  if (audio_setting_ == CONTENT_SETTING_BLOCK ||

[Timothy Loh, 2017/04/24 04:18:57]

Should this be an &&? Looks like RunCallback() will ignore the denial reason for
ALLOW+BLOCK (i.e. one was already set).

Also it seems like we now we return DENIED for BLOCK+ASK (i.e. one was already
blocked) instead of DISMISSED, is one of these better than the other?

[raymes, 2017/04/26 00:10:30]

We should only really be updating |denial_reason_| here based on |response| not
based on previous settings, so I've fixed that. But otherwise I don't think it
matters - previously there would only be one response to the prompt, but now
there are potentially 2. They should never really be ASK and BLOCK together
though. 

[Timothy Loh, 2017/04/26 01:40:25]

OK, sounds reasonable.

+      video_setting_ == CONTENT_SETTING_BLOCK) {
+    denial_reason_ = content::MEDIA_DEVICE_PERMISSION_DENIED;
+  } else if (audio_setting_ == CONTENT_SETTING_ASK ||
+             video_setting_ == CONTENT_SETTING_ASK) {
+    denial_reason_ = content::MEDIA_DEVICE_PERMISSION_DISMISSED;
+  }
+
+  RunCallback();
+}
+
 #if defined(OS_ANDROID)
 void MediaStreamDevicesController::AndroidOSPromptAnswered(bool allowed) {
   DCHECK(audio_setting_ != CONTENT_SETTING_ASK &&
          video_setting_ != CONTENT_SETTING_ASK);
 
   if (!allowed) {
     denial_reason_ = content::MEDIA_DEVICE_PERMISSION_DENIED;
     // Only permissions that were previously ALLOW for a site will have had
     // their android permissions requested. It's only in that case that we need
     // to change the setting to BLOCK to reflect that it wasn't allowed.
     if (audio_setting_ == CONTENT_SETTING_ALLOW)
       audio_setting_ = CONTENT_SETTING_BLOCK;
     if (video_setting_ == CONTENT_SETTING_ALLOW)
       video_setting_ = CONTENT_SETTING_BLOCK;
   }
 
   RunCallback();
 }
 #endif  // defined(OS_ANDROID)
 
 void MediaStreamDevicesController::RequestFinishedNoPrompt() {
   RunCallback();
 }
 
 // static
 void MediaStreamDevicesController::RequestPermissionsWithDelegate(
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     PermissionPromptDelegate* delegate) {
+  content::RenderFrameHost* rfh = content::RenderFrameHost::FromID(
+      request.render_process_id, request.render_frame_id);
   content::WebContents* web_contents =
-      content::WebContents::FromRenderFrameHost(
-          content::RenderFrameHost::FromID(request.render_process_id,
-                                           request.render_frame_id));
+      content::WebContents::FromRenderFrameHost(rfh);
   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));
   }
 
   std::unique_ptr<MediaStreamDevicesController> controller(
       new MediaStreamDevicesController(web_contents, request, callback));
 
   // Show a prompt if needed.
   if (controller->IsAskingForAudio() || controller->IsAskingForVideo()) {
     Profile* profile =
         Profile::FromBrowserContext(web_contents->GetBrowserContext());
-    delegate->ShowPrompt(
-        request.user_gesture, web_contents,
-        base::MakeUnique<Request>(
-            profile, controller->IsAskingForAudio(),
-            controller->IsAskingForVideo(), request.security_origin,
-            base::Bind(&MediaStreamDevicesController::PromptAnswered,
-                       base::Passed(&controller))));
+    if (base::FeatureList::IsEnabled(
+            features::kUsePermissionManagerForMediaRequests)) {
+      std::vector<ContentSettingsType> content_settings_types;
+
+      if (controller->IsAskingForAudio())
+        content_settings_types.push_back(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC);
+      if (controller->IsAskingForVideo()) {
+        content_settings_types.push_back(
+            CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
+      }
+
+      PermissionManager::Get(profile)->RequestPermissions(
+          content_settings_types, rfh, request.security_origin,
+          request.user_gesture,
+          base::Bind(
+              &MediaStreamDevicesController::PromptAnsweredGroupedRequest,
+              base::Passed(&controller)));
+    } else {
+      delegate->ShowPrompt(
+          request.user_gesture, web_contents,
+          base::MakeUnique<Request>(
+              profile, controller->IsAskingForAudio(),
+              controller->IsAskingForVideo(), request.security_origin,
+              base::Bind(&MediaStreamDevicesController::PromptAnswered,
+                         base::Passed(&controller))));
+    }
     return;
   }
 
 #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);
@@ skipping 273 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;
 }