Enable the optional permission prompt persistence toggle on grouped infobars

chrome/browser/media/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/media_stream_devices_controller.h"
 
 #include <map>
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.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/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/media_permission.h"
 #include "chrome/browser/media/media_stream_capture_indicator.h"
 #include "chrome/browser/media/media_stream_device_permissions.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/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"
@@ skipping 125 matching lines @@
 
 }  // namespace
 
 MediaStreamDevicesController::MediaStreamDevicesController(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback)
     : web_contents_(web_contents),
       request_(request),
       callback_(callback),
-      persist_permission_changes_(true) {
+      persist_(true) {
   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));
   }
   profile_ = Profile::FromBrowserContext(web_contents->GetBrowserContext());
   content_settings_ = TabSpecificContentSettings::FromWebContents(web_contents);
 
   content::MediaStreamRequestResult denial_reason = content::MEDIA_DEVICE_OK;
   old_audio_setting_ = GetContentSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
@@ skipping 71 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() {
-  base::AutoReset<bool> persist_permissions(
-      &persist_permission_changes_, false);
+  base::AutoReset<bool> persist_permissions(&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);
 }
 
 int MediaStreamDevicesController::GetIconId() const {
   if (IsAskingForVideo())
     return IDR_INFOBAR_MEDIA_STREAM_CAMERA;
@@ skipping 182 matching lines @@
 }
 
 void MediaStreamDevicesController::RunCallback(
     ContentSetting audio_setting,
     ContentSetting video_setting,
     content::MediaStreamRequestResult denial_reason) {
   CHECK(!callback_.is_null());
 
   // If the kill switch is on we don't update the tab context or persist the
   // setting.
-  if (persist_permission_changes_ &&
-      denial_reason != content::MEDIA_DEVICE_KILL_SWITCH_ON) {
-    StorePermission(audio_setting, video_setting);
+  if (denial_reason != content::MEDIA_DEVICE_KILL_SWITCH_ON) {
+    if (persist())
+      StorePermission(audio_setting, video_setting);
     UpdateTabSpecificContentSettings(audio_setting, video_setting);
   }
 
   content::MediaStreamDevices devices =
       GetDevices(audio_setting, video_setting);
 
   // If either audio or video are allowed then the callback should report
   // success, otherwise we report |denial_reason|.
   content::MediaStreamRequestResult request_result = content::MEDIA_DEVICE_OK;
   if (audio_setting != CONTENT_SETTING_ALLOW &&
@@ skipping 94 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;
-  if (content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC) {
-    permission_type = content::PermissionType::AUDIO_CAPTURE;
-  } else {
-    DCHECK(content_type == CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
-    permission_type = content::PermissionType::VIDEO_CAPTURE;
-  }
-
+  content::PermissionType permission_type =
+      GetPermissionTypeForContentSettingsType(content_type);
   if (ContentTypeIsRequested(permission_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 40 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;
 }