ScreenCapture for Android phase1, part II

chrome/browser/media/webrtc/permission_bubble_media_access_handler.cc

 // Copyright 2015 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/permission_bubble_media_access_handler.h"
 
 #include <utility>
 
 #include "base/metrics/field_trial.h"
 #include "chrome/browser/media/webrtc/media_permission.h"
 #include "chrome/browser/media/webrtc/media_stream_device_permissions.h"
 #include "chrome/browser/media/webrtc/media_stream_devices_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/features.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/web_contents.h"
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
+#include "chrome/browser/android/chrome_feature_list.h"
 #include "chrome/browser/media/webrtc/media_stream_infobar_delegate_android.h"
 #include "chrome/browser/permissions/permission_update_infobar_delegate_android.h"
 #else
 #include "chrome/browser/permissions/permission_request_manager.h"
 #endif  // BUILDFLAG(ANDROID_JAVA_UI)
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 namespace {
 // Callback for the permission update infobar when the site and Chrome
 // permissions are mismatched on Android.
@@ skipping 33 matching lines @@
                                content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                                content::NotificationService::AllSources());
 }
 
 PermissionBubbleMediaAccessHandler::~PermissionBubbleMediaAccessHandler() {
 }
 
 bool PermissionBubbleMediaAccessHandler::SupportsStreamType(
     const content::MediaStreamType type,
     const extensions::Extension* extension) {
+#if BUILDFLAG(ANDROID_JAVA_UI)
+  return type == content::MEDIA_DEVICE_VIDEO_CAPTURE ||
+         type == content::MEDIA_DEVICE_AUDIO_CAPTURE ||
+         type == content::MEDIA_DESKTOP_VIDEO_CAPTURE;
+#else
   return type == content::MEDIA_DEVICE_VIDEO_CAPTURE ||
          type == content::MEDIA_DEVICE_AUDIO_CAPTURE;
+#endif
 }
 
 bool PermissionBubbleMediaAccessHandler::CheckMediaAccessPermission(
     content::WebContents* web_contents,
     const GURL& security_origin,
     content::MediaStreamType type,
     const extensions::Extension* extension) {
   Profile* profile =
       Profile::FromBrowserContext(web_contents->GetBrowserContext());
   ContentSettingsType content_settings_type =
       type == content::MEDIA_DEVICE_AUDIO_CAPTURE
           ? CONTENT_SETTINGS_TYPE_MEDIASTREAM_MIC
           : CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA;
 
   MediaPermission permission(content_settings_type, security_origin,
       web_contents->GetLastCommittedURL().GetOrigin(), profile);
   content::MediaStreamRequestResult unused;
   return permission.GetPermissionStatus(&unused) == CONTENT_SETTING_ALLOW;
 }
 
 void PermissionBubbleMediaAccessHandler::HandleRequest(
     content::WebContents* web_contents,
     const content::MediaStreamRequest& request,
     const content::MediaResponseCallback& callback,
     const extensions::Extension* extension) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
+#if BUILDFLAG(ANDROID_JAVA_UI)
+  if (request.video_type == content::MEDIA_DESKTOP_VIDEO_CAPTURE &&
+      !base::FeatureList::IsEnabled(
+          chrome::android::kUserMediaScreenCapturing)) {
+    // If screen capturing isn't enabled on Android, we'll use "invalid state"
+    // as result, same as on desktop.
+    callback.Run(content::MediaStreamDevices(),
+                 content::MEDIA_DEVICE_INVALID_STATE, nullptr);
+    return;
+  }
+#endif  // BUILDFLAG(ANDROID_JAVA_UI)
+
   RequestsQueue& queue = pending_requests_[web_contents];
   queue.push_back(PendingAccessRequest(request, callback));
 
   // If this is the only request then show the infobar.
   if (queue.size() == 1)
     ProcessQueuedAccessRequest(web_contents);
 }
 
 void PermissionBubbleMediaAccessHandler::ProcessQueuedAccessRequest(
     content::WebContents* web_contents) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::map<content::WebContents*, RequestsQueue>::iterator it =
       pending_requests_.find(web_contents);
 
   if (it == pending_requests_.end() || it->second.empty()) {
     // Don't do anything if the tab was closed.
     return;
   }
 
   DCHECK(!it->second.empty());
 
   std::unique_ptr<MediaStreamDevicesController> controller(

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

If you added a new InfoBarDelegate class, you would use it here instead of
creating a controller.

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

Done.

       new MediaStreamDevicesController(
           web_contents, it->second.front().request,
           base::Bind(
               &PermissionBubbleMediaAccessHandler::OnAccessRequestResponse,
               base::Unretained(this), web_contents)));
-  if (!controller->IsAskingForAudio() && !controller->IsAskingForVideo()) {
+  if (!controller->IsAskingForAudio() && !controller->IsAskingForVideo() &&
+      !controller->IsAskingForScreenCapture()) {
 #if BUILDFLAG(ANDROID_JAVA_UI)
     // 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()) {
       content_settings_types.push_back(
@@ skipping 87 matching lines @@
 
 void PermissionBubbleMediaAccessHandler::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(content::NOTIFICATION_WEB_CONTENTS_DESTROYED, type);
 
   pending_requests_.erase(content::Source<content::WebContents>(source).ptr());
 }