ScreenCapture for Android phase1, part II

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/auto_reset.h"
 #include "base/callback_helpers.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/desktop_streams_registry.h"
 #include "chrome/browser/media/webrtc/media_capture_devices_dispatcher.h"
 #include "chrome/browser/media/webrtc/media_permission.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_uma_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 "chrome/grit/theme_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/permission_type.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/common/media_stream_request.h"
 #include "content/public/common/origin_util.h"
 #include "extensions/common/constants.h"
+#include "third_party/webrtc/modules/desktop_capture/desktop_capture_types.h"
 #include "ui/base/l10n/l10n_util.h"
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include <vector>
 
 #include "chrome/browser/android/preferences/pref_service_bridge.h"
 #include "chrome/browser/permissions/permission_update_infobar_delegate_android.h"
 #include "content/public/browser/android/content_view_core.h"
 #include "ui/android/window_android.h"
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
@@ skipping 144 matching lines @@
   }
 
   // If the site had been previously granted the access to audio or video but
   // Chrome is now missing the necessary permission, we need to show an infobar
   // to resolve the difference.
   if (!content_settings_types.empty() &&
       PermissionUpdateInfoBarDelegate::ShouldShowPermissionInfobar(
           web_contents, content_settings_types)) {
     return;
   }
+
+  // Always show infobar for screen capture on Android.
+  if (request.video_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE)
+    return;
 #endif
 
   // Otherwise we can run the callback immediately.
   RunCallback(old_audio_setting_, old_video_setting_, denial_reason);
 }
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
     RecordPermissionAction(request_, profile_,
                            base::Bind(PermissionUmaUtil::PermissionIgnored));
@@ skipping 21 matching lines @@
 }
 
 bool MediaStreamDevicesController::IsAskingForAudio() const {
   return old_audio_setting_ == CONTENT_SETTING_ASK;
 }
 
 bool MediaStreamDevicesController::IsAskingForVideo() const {
   return old_video_setting_ == CONTENT_SETTING_ASK;
 }
 
+bool MediaStreamDevicesController::IsAskingForScreenCapture() const {
+  return request_.video_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE;
+}
+
 base::string16 MediaStreamDevicesController::GetMessageText() const {
   int message_id = IDS_MEDIA_CAPTURE_AUDIO_AND_VIDEO;
-  if (!IsAskingForAudio())
+  if (IsAskingForScreenCapture()) {
+    message_id = IDS_MEDIA_SCREEN_CAPTURE_CONFIRMATION_TEXT;
+  } else if (!IsAskingForAudio()) {
     message_id = IDS_MEDIA_CAPTURE_VIDEO_ONLY;
-  else if (!IsAskingForVideo())
+  } 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));
 }
 
 void MediaStreamDevicesController::ForcePermissionDeniedTemporarily() {
   base::AutoReset<bool> persist_permissions(
       &persist_permission_changes_, false);
   // TODO(tsergeant): Determine whether it is appropriate to record permission
@@ skipping 19 matching lines @@
   return l10n_util::GetStringUTF16(message_id);
 }
 
 GURL MediaStreamDevicesController::GetOrigin() const {
   return request_.security_origin;
 }
 
 void MediaStreamDevicesController::PermissionGranted() {
   RecordPermissionAction(request_, profile_,
                          base::Bind(PermissionUmaUtil::PermissionGranted));
-  RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                            old_audio_setting_, CONTENT_SETTING_ALLOW),
-              GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                            old_video_setting_, CONTENT_SETTING_ALLOW),
-              content::MEDIA_DEVICE_PERMISSION_DENIED);
+  if (IsAskingForScreenCapture()) {
+    RunCallback(old_audio_setting_, old_video_setting_,
+                content::MEDIA_DEVICE_OK);
+  } else {
+    RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+                              old_audio_setting_, CONTENT_SETTING_ALLOW),
+                GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                              old_video_setting_, CONTENT_SETTING_ALLOW),
+                content::MEDIA_DEVICE_PERMISSION_DENIED);
+  }
 }
 
 void MediaStreamDevicesController::PermissionDenied() {
   RecordPermissionAction(request_, profile_,
                          base::Bind(PermissionUmaUtil::PermissionDenied));
-  RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
-                            old_audio_setting_, CONTENT_SETTING_BLOCK),
-              GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
-                            old_video_setting_, CONTENT_SETTING_BLOCK),
-              content::MEDIA_DEVICE_PERMISSION_DENIED);
+  if (IsAskingForScreenCapture()) {
+    RunCallback(old_audio_setting_, old_video_setting_,
+                content::MEDIA_DEVICE_PERMISSION_DENIED);
+  } else {
+    RunCallback(GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC,
+                              old_audio_setting_, CONTENT_SETTING_BLOCK),
+                GetNewSetting(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA,
+                              old_video_setting_, CONTENT_SETTING_BLOCK),
+                content::MEDIA_DEVICE_PERMISSION_DENIED);
+  }
 }
 
 void MediaStreamDevicesController::GroupedRequestFinished(bool audio_accepted,
                                                           bool video_accepted) {
   RecordSinglePermissionAction(
       request_, content::PermissionType::AUDIO_CAPTURE, profile_,
       base::Bind(audio_accepted ? PermissionUmaUtil::PermissionGranted
                                 : PermissionUmaUtil::PermissionDenied));
   RecordSinglePermissionAction(
       request_, content::PermissionType::VIDEO_CAPTURE, profile_,
@@ skipping 146 matching lines @@
   // setting.
   if (persist_permission_changes_ &&
       denial_reason != content::MEDIA_DEVICE_KILL_SWITCH_ON) {
     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 &&
-      video_setting != CONTENT_SETTING_ALLOW) {
+  if (IsAskingForScreenCapture()) {

[tsergeant, 2016/09/13 05:06:23]

My suggestion would be to avoid modifying media_stream_devices_controller and
media_stream_infobar_delegate if possible. There's a lot of logic in there
already to
handle the ways in which video/audio permissions interact, which you probably
don't want to get involved with.

One way to do this would be to add a new ConfirmInfoBarDelegate subclass.
Hopefully that won't be too much work, since the critical parts are just setting
up the strings, icons and buttons (which are mostly static), and using roughly
the same callback method as is used here.

Using a new infobar delegate means that you can get the behavior you want here
without worrying about how it interacts with the existing permissions. You also
wouldn't need to worry about adding a new content setting. 

[braveyao, 2016/09/15 21:29:31]

Done.

+    request_result = denial_reason;
+    if (request_result == content::MEDIA_DEVICE_OK) {
+      content::DesktopMediaID screen_id;
+      screen_id = content::DesktopMediaID(content::DesktopMediaID::TYPE_SCREEN,
+                                          webrtc::kFullDesktopScreenId);
+      devices.push_back(
+          content::MediaStreamDevice(content::MEDIA_DESKTOP_VIDEO_CAPTURE,
+                                     screen_id.ToString(), "Screen"));
+    }
+  } else if (audio_setting != CONTENT_SETTING_ALLOW &&
+             video_setting != CONTENT_SETTING_ALLOW) {
+    // If either audio or video are allowed then the callback should report
+    // success, otherwise we report |denial_reason|.
     DCHECK_NE(content::MEDIA_DEVICE_OK, denial_reason);
     request_result = denial_reason;
   } else if (devices.empty()) {
     // Even if one of the content settings was allowed, if there are no devices
     // at this point we still report a failure.
     request_result = content::MEDIA_DEVICE_NO_HARDWARE;
   }
 
   std::unique_ptr<content::MediaStreamUI> ui;
   if (!devices.empty()) {
@@ skipping 151 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;
 }