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));

[miu, 2016/09/07 21:10:03]

Seems like the extra bool argument is not needed, since the device ID will
contain the mute option flag. That way, you won't need the |mute_source| member
added to this class either.

[qiangchen, 2016/09/09 18:45:24]

We need it. Because at this point, the device_id is still encrypted, we need to
pass |mute_source| info into the DesktopCaptureAccessHandler, and it is in the
DesktopCaptureAccessHandler we look up the registry and translate id into a
DesktopMediaID and prepare the |mute_source| information into the
DesktopMediaID.

   }
 
   // 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;
+
  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 944 matching lines @@
 
   bool has_valid_device_id = WebContentsMediaCaptureId::ExtractTabCaptureTarget(
       capture_device_id, &target_render_process_id, &target_render_frame_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;
+  // TODO(qiangchen): Plug in constraint value here for tabCapture.
+  request->mute_source = request->controls.mute_source_audio;
+
+  content::WebContentsMediaCaptureId web_id =
+      content::WebContentsMediaCaptureId::Parse(capture_device_id);
+  web_id.mute_source = request->mute_source;
+  request->tab_capture_device_id = web_id.ToString();
 
   request->CreateTabCaptureUIRequest(target_render_process_id,
                                      target_render_frame_id);
 
   DVLOG(3) << "SetupTabCaptureRequest "
            << ", {capture_device_id = " << capture_device_id <<  "}"
            << ", {target_render_process_id = " << target_render_process_id
            << "}"
            << ", {target_render_frame_id = " << target_render_frame_id << "}";
   return true;
@@ skipping 15 matching lines @@
 
   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