Let Contraints Controll Mute/Unmute Audio Local Playback For Desktop Sharing

content/browser/renderer_host/media/media_stream_manager.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 "content/browser/renderer_host/media/media_stream_manager.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 291 matching lines @@
   // is asked for permission and device selection.
   void CreateUIRequest(const std::string& requested_audio_device_id,
                        const std::string& requested_video_device_id) {
     DCHECK(!ui_request_);
     target_process_id_ = requesting_process_id;
     target_frame_id_ = requesting_frame_id;
     ui_request_.reset(new MediaStreamRequest(
         requesting_process_id, requesting_frame_id, page_request_id,
         ConvertToGURL(security_origin), user_gesture, request_type,
         requested_audio_device_id, requested_video_device_id, audio_type_,
-        video_type_));
+        video_type_, controls.disable_local_echo));
   }
 
   // Creates a tab capture specific MediaStreamRequest object that is used by
   // this request when UI is asked for permission and device selection.
   void CreateTabCaptureUIRequest(int target_render_process_id,
                                  int target_render_frame_id) {
     DCHECK(!ui_request_);
     target_process_id_ = target_render_process_id;
     target_frame_id_ = target_render_frame_id;
     ui_request_.reset(new MediaStreamRequest(
         target_render_process_id, target_render_frame_id, page_request_id,
         ConvertToGURL(security_origin), user_gesture, request_type, "", "",
-        audio_type_, video_type_));
+        audio_type_, video_type_, controls.disable_local_echo));
   }
 
   bool HasUIRequest() const { return ui_request_.get() != nullptr; }
   std::unique_ptr<MediaStreamRequest> DetachUIRequest() {
     return std::move(ui_request_);
   }
 
   // Update the request state and notify observers.
   void SetState(MediaStreamType stream_type, MediaRequestState new_state) {
     if (stream_type == NUM_MEDIA_TYPES) {
@@ skipping 203 matching lines @@
                                         bool user_gesture) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DVLOG(1) << "GenerateStream()";
 
   DeviceRequest* request = new DeviceRequest(
       requester, render_process_id, render_frame_id, page_request_id,
       security_origin, user_gesture, MEDIA_GENERATE_STREAM, controls, salt);
 
   const std::string& label = AddRequest(request);
 
+  if (!generate_stream_test_callback_.is_null()) {
+    // The test callback is responsible to verify whether the |controls| is
+    // as expected. Then we need to finish getUserMedia and let Javascript
+    // access the result.
+    if (generate_stream_test_callback_.Run(controls)) {
+      FinalizeGenerateStream(label, request);
+    } else {
+      FinalizeRequestFailed(label, request, MEDIA_DEVICE_INVALID_STATE);
+    }
+    return;
+  }
+
   // Post a task and handle the request asynchronously. The reason is that the
   // requester won't have a label for the request until this function returns
   // and thus can not handle a response. Using base::Unretained is safe since
   // MediaStreamManager is deleted on the UI thread, after the IO thread has
   // been stopped.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamManager::SetupRequest,
                  base::Unretained(this), label));
 }
@@ skipping 620 matching lines @@
   std::string capture_device_id;
   if (!request->controls.audio.device_ids.empty()) {
     capture_device_id = request->controls.audio.device_ids[0];
   } else if (!request->controls.video.device_ids.empty()) {
     capture_device_id = request->controls.video.device_ids[0];
   } else {
     return false;
   }
 
   // Customize controls for a WebContents based capture.
-  int target_render_process_id = 0;
-  int target_render_frame_id = 0;
-
-  bool has_valid_device_id = WebContentsMediaCaptureId::ExtractTabCaptureTarget(
-      capture_device_id, &target_render_process_id, &target_render_frame_id);
+  content::WebContentsMediaCaptureId web_id;
+  bool has_valid_device_id =
+      WebContentsMediaCaptureId::Parse(capture_device_id, &web_id);
   if (!has_valid_device_id ||
       (request->audio_type() != MEDIA_TAB_AUDIO_CAPTURE &&
        request->audio_type() != MEDIA_NO_SERVICE) ||
       (request->video_type() != MEDIA_TAB_VIDEO_CAPTURE &&
        request->video_type() != MEDIA_NO_SERVICE)) {
     return false;
   }
-  request->tab_capture_device_id = capture_device_id;
+  web_id.disable_local_echo = request->controls.disable_local_echo;
 
-  request->CreateTabCaptureUIRequest(target_render_process_id,
-                                     target_render_frame_id);
+  request->tab_capture_device_id = web_id.ToString();
+
+  request->CreateTabCaptureUIRequest(web_id.render_process_id,
+                                     web_id.main_render_frame_id);
 
   DVLOG(3) << "SetupTabCaptureRequest "
-           << ", {capture_device_id = " << capture_device_id <<  "}"
-           << ", {target_render_process_id = " << target_render_process_id
+           << ", {capture_device_id = " << capture_device_id << "}"
+           << ", {target_render_process_id = " << web_id.render_process_id
            << "}"
-           << ", {target_render_frame_id = " << target_render_frame_id << "}";
+           << ", {target_render_frame_id = " << web_id.main_render_frame_id
+           << "}";
   return true;
 }
 
 bool MediaStreamManager::SetupScreenCaptureRequest(DeviceRequest* request) {
   DCHECK(request->audio_type() == MEDIA_DESKTOP_AUDIO_CAPTURE ||
          request->video_type() == MEDIA_DESKTOP_VIDEO_CAPTURE);
 
   // For screen capture we only support two valid combinations:
   // (1) screen video capture only, or
   // (2) screen video capture with loopback audio capture.
@@ skipping 814 matching lines @@
     if (request->request_type == MEDIA_ENUMERATE_DEVICES &&
         request->state(stream_type) == MEDIA_REQUEST_STATE_REQUESTED &&
         (request->audio_type() == stream_type ||
          request->video_type() == stream_type)) {
       ProcessEnumerationRequest(labeled_request.first, request, stream_type,
                                 device_infos);
     }
   }
 }
 
+void MediaStreamManager::SetGenerateStreamCallbackForTesting(
+    GenerateStreamTestCallback test_callback) {
+  generate_stream_test_callback_ = test_callback;
+}
+
 }  // namespace content