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 <string.h>
 #include <algorithm>
@@ skipping 240 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_, mute_source));
   }
 
   // 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_, mute_source));
   }
 
   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 62 matching lines @@
 
   // Callback to the requester which audio/video devices have been selected.
   // It can be null if the requester has no interest to know the result.
   // Currently it is only used by |DEVICE_ACCESS| type.
   MediaStreamManager::MediaRequestResponseCallback callback;
 
   std::unique_ptr<MediaStreamUIProxy> ui_proxy;
 
   std::string tab_capture_device_id;
 
+  bool mute_source;

[miu, 2016/09/12 23:13:12]

naming nit: We're not really muting the source, we're muting output to the local
audio device. So, for clarity, this should be named something like
|disable_local_echo| or |disable_local_output|. (IMHO, the first one's better
since it also implies there's a capture/loop-back mechanism involved, similar to
how we describe "local echo" for console output.)

...and, please change everywhere else to match (including StreamControls, IPC
message field, WebContentsMediaCaptureId data member and method args,
MediaStreamRequest, etc).

Also, please add a comment here like: "Set to true to prevent
captured/looped-back audio from also playing out locally."

[qiangchen, 2016/09/13 21:46:57]

Done.

+
  private:
   std::vector<MediaRequestState> state_;
   std::unique_ptr<MediaStreamRequest> ui_request_;
   MediaStreamType audio_type_;
   MediaStreamType video_type_;
   int target_process_id_;
   int target_frame_id_;
 };
 
 MediaStreamManager::EnumerationCache::EnumerationCache()
@@ skipping 934 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::TryParse(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;
+  request->mute_source = request->controls.mute_source_audio;
+  web_id.mute_source = request->mute_source;
 
-  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.
   if (request->video_type() != MEDIA_DESKTOP_VIDEO_CAPTURE ||
       (request->audio_type() != MEDIA_NO_SERVICE &&
        request->audio_type() != MEDIA_DESKTOP_AUDIO_CAPTURE)) {
     LOG(ERROR) << "Invalid screen capture request.";
     return false;
   }
 
   std::string video_device_id;
   if (request->video_type() == MEDIA_DESKTOP_VIDEO_CAPTURE) {
     const std::string& video_stream_source =
         request->controls.video.stream_source;
 
     if (video_stream_source == kMediaStreamSourceDesktop &&
         !request->controls.video.device_ids.empty()) {
       video_device_id = request->controls.video.device_ids[0];
     }
+    request->mute_source = request->controls.mute_source_audio;
   }
 
   const std::string audio_device_id =
       request->audio_type() == MEDIA_DESKTOP_AUDIO_CAPTURE ? video_device_id
                                                            : "";
 
   request->CreateUIRequest(audio_device_id, video_device_id);
   return true;
 }
 
@@ skipping 814 matching lines @@
       if (device_info.session_id == session_id &&
           device_info.device.type == type) {
         request->SetCapturingLinkSecured(is_secure);
         return;
       }
     }
   }
 }
 
 }  // namespace content