ScreenCapture for Android phase1, part II

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/desktop_streams_registry.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/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"
 #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 "grit/theme_resources.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()) {
+    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;
 }