Pass stream source as MediaStreamType in TrackControls

This CL completes a TODO in media_stream_controls.h, by switching from
std::string to MediaStreamType. Accordingly, it changes related mojo files,
renderer side UserMediaProcessor and browser side MediaStreamManager.

This will let us add new MediaStreamTypes for request in follow-up CLs.

Bug: 326740
Change-Id: I13e2613c190d342c95f084b3a06933a9458a12a8
Reviewed-on: https://chromium-review.googlesource.com/1159839Reviewed-by: Will Harris <wfh@chromium.org>
Reviewed-by: Christian Fremerey <chfremer@chromium.org>
Reviewed-by: Avi Drissman <avi@chromium.org>
Reviewed-by: Sergey Ulanov <sergeyu@chromium.org>
Reviewed-by: Dan Sanders <sandersd@chromium.org>
Commit-Queue: Emircan Uysaler <emircan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#580613}

chrome/browser/media/webrtc/media_capture_devices_dispatcher.cc

@@ -390,7 +390,8 @@ void MediaCaptureDevicesDispatcher::UpdateMediaRequestStateOnUIThread(
   }
 
 #if defined(OS_CHROMEOS)
-  if (IsOriginForCasting(security_origin) && IsVideoMediaType(stream_type)) {
+  if (IsOriginForCasting(security_origin) &&
+      IsVideoInputMediaType(stream_type)) {
     // Notify ash that casting state has changed.
     if (state == content::MEDIA_REQUEST_STATE_DONE) {
       ash::Shell::Get()->OnCastingSessionStartedOrStopped(true);

content/browser/renderer_host/media/media_stream_dispatcher_host_unittest.cc

@@ -185,7 +185,7 @@ class MockMediaStreamDispatcherHost : public MediaStreamDispatcherHost,
 
   void OnDeviceStoppedInternal(const std::string& label,
                                const MediaStreamDevice& device) {
-    if (IsVideoMediaType(device.type))
+    if (IsVideoInputMediaType(device.type))
       EXPECT_TRUE(device.IsSameDevice(video_devices_[0]));
     if (IsAudioInputMediaType(device.type))
       EXPECT_TRUE(device.IsSameDevice(audio_devices_[0]));

content/browser/renderer_host/media/media_stream_manager.cc

@@ -100,47 +100,6 @@ std::string RandomLabel() {
   return label;
 }
 
-void ParseStreamType(const StreamControls& controls,
-                     MediaStreamType* audio_type,
-                     MediaStreamType* video_type) {
-  *audio_type = MEDIA_NO_SERVICE;
-  *video_type = MEDIA_NO_SERVICE;
-  const bool audio_support_flag_for_desktop_share =
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisableAudioSupportForDesktopShare);
-  if (controls.audio.requested) {
-    if (!controls.audio.stream_source.empty()) {
-      // This is tab or screen capture.
-      if (controls.audio.stream_source == kMediaStreamSourceTab) {
-        *audio_type = MEDIA_TAB_AUDIO_CAPTURE;
-      } else if (controls.audio.stream_source == kMediaStreamSourceSystem) {
-        *audio_type = MEDIA_DESKTOP_AUDIO_CAPTURE;
-      } else if (audio_support_flag_for_desktop_share &&
-                 controls.audio.stream_source == kMediaStreamSourceDesktop) {
-        *audio_type = MEDIA_DESKTOP_AUDIO_CAPTURE;
-      }
-    } else {
-      // This is normal audio device capture.
-      *audio_type = MEDIA_DEVICE_AUDIO_CAPTURE;
-    }
-  }
-  if (controls.video.requested) {
-    if (!controls.video.stream_source.empty()) {
-      // This is tab or screen capture.
-      if (controls.video.stream_source == kMediaStreamSourceTab) {
-        *video_type = MEDIA_TAB_VIDEO_CAPTURE;
-      } else if (controls.video.stream_source == kMediaStreamSourceScreen) {
-        *video_type = MEDIA_DESKTOP_VIDEO_CAPTURE;
-      } else if (controls.video.stream_source == kMediaStreamSourceDesktop) {
-        *video_type = MEDIA_DESKTOP_VIDEO_CAPTURE;
-      }
-    } else {
-      // This is normal video device capture.
-      *video_type = MEDIA_DEVICE_VIDEO_CAPTURE;
-    }
-  }
-}
-
 // Turns off available audio effects (removes the flag) if the options
 // explicitly turn them off.
 void FilterAudioEffects(const StreamControls& controls, int* effects) {
@@ -216,6 +175,17 @@ void SendVideoCaptureLogMessage(const std::string& message) {
   MediaStreamManager::SendMessageToNativeLog("video capture: " + message);
 }
 
+MediaStreamType AdjustAudioStreamTypeBasedOnCommandLineSwitches(
+    MediaStreamType stream_type) {
+  if (stream_type != MEDIA_DESKTOP_AUDIO_CAPTURE)
+    return stream_type;
+  const bool audio_support_flag_for_desktop_share =
+      !base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kDisableAudioSupportForDesktopShare);
+  return audio_support_flag_for_desktop_share ? MEDIA_DESKTOP_AUDIO_CAPTURE
+                                              : MEDIA_NO_SERVICE;
+}
+
 }  // namespace
 
 // MediaStreamManager::DeviceRequest represents a request to either enumerate
@@ -259,7 +229,7 @@ class MediaStreamManager::DeviceRequest {
   MediaStreamType audio_type() const { return audio_type_; }
 
   void SetVideoType(MediaStreamType video_type) {
-    DCHECK(IsVideoMediaType(video_type) || video_type == MEDIA_NO_SERVICE);
+    DCHECK(IsVideoInputMediaType(video_type) || video_type == MEDIA_NO_SERVICE);
     video_type_ = video_type;
   }
 
@@ -809,9 +779,11 @@ void MediaStreamManager::OpenDevice(int render_process_id,
   StreamControls controls;
   if (IsAudioInputMediaType(type)) {
     controls.audio.requested = true;
+    controls.audio.stream_type = type;
     controls.audio.device_id = device_id;
-  } else if (IsVideoMediaType(type)) {
+  } else if (IsVideoInputMediaType(type)) {
     controls.video.requested = true;
+    controls.video.stream_type = type;
     controls.video.device_id = device_id;
   } else {
     NOTREACHED();
@@ -1053,7 +1025,7 @@ void MediaStreamManager::PostRequestToUI(
   // Post the request to UI and set the state.
   if (IsAudioInputMediaType(audio_type))
     request->SetState(audio_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
-  if (IsVideoMediaType(video_type))
+  if (IsVideoInputMediaType(video_type))
     request->SetState(video_type, MEDIA_REQUEST_STATE_PENDING_APPROVAL);
 
   // If using the fake UI, it will just auto-select from the available devices.
@@ -1092,30 +1064,30 @@ void MediaStreamManager::SetUpRequest(const std::string& label) {
     return;  // This can happen if the request has been canceled.
   }
 
-  MediaStreamType audio_type = MEDIA_NO_SERVICE;
-  MediaStreamType video_type = MEDIA_NO_SERVICE;
-  ParseStreamType(request->controls, &audio_type, &video_type);
-  request->SetAudioType(audio_type);
-  request->SetVideoType(video_type);
+  request->SetAudioType(AdjustAudioStreamTypeBasedOnCommandLineSwitches(
+      request->controls.audio.stream_type));
+  request->SetVideoType(request->controls.video.stream_type);
 
-  const bool is_web_contents_capture = audio_type == MEDIA_TAB_AUDIO_CAPTURE ||
-                                       video_type == MEDIA_TAB_VIDEO_CAPTURE;
-  if (is_web_contents_capture) {
+  const bool is_tab_capture =
+      request->audio_type() == MEDIA_TAB_AUDIO_CAPTURE ||
+      request->video_type() == MEDIA_TAB_VIDEO_CAPTURE;
+  if (is_tab_capture) {
     if (!SetUpTabCaptureRequest(request, label)) {
       FinalizeRequestFailed(label, request, MEDIA_DEVICE_TAB_CAPTURE_FAILURE);
     }
     return;
   }
 
-  const bool is_screen_capture = video_type == MEDIA_DESKTOP_VIDEO_CAPTURE;
+  const bool is_screen_capture =
+      request->video_type() == MEDIA_DESKTOP_VIDEO_CAPTURE;
   if (is_screen_capture && !SetUpScreenCaptureRequest(request)) {
     FinalizeRequestFailed(label, request, MEDIA_DEVICE_SCREEN_CAPTURE_FAILURE);
     return;
   }
 
-  if (!is_web_contents_capture && !is_screen_capture) {
-    if (audio_type == MEDIA_DEVICE_AUDIO_CAPTURE ||
-        video_type == MEDIA_DEVICE_VIDEO_CAPTURE) {
+  if (!is_tab_capture && !is_screen_capture) {
+    if (IsDeviceMediaType(request->audio_type()) ||
+        IsDeviceMediaType(request->video_type())) {
       StartEnumeration(request, label);
       return;
     }
@@ -1256,11 +1228,7 @@ bool MediaStreamManager::SetUpScreenCaptureRequest(DeviceRequest* request) {
 
   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_id.empty()) {
+    if (!request->controls.video.device_id.empty()) {
       video_device_id = request->controls.video.device_id;
     }
   }
@@ -1329,7 +1297,7 @@ void MediaStreamManager::FinalizeGenerateStream(const std::string& label,
   for (const MediaStreamDevice& device : request->devices) {
     if (IsAudioInputMediaType(device.type))
       audio_devices.push_back(device);
-    else if (IsVideoMediaType(device.type))
+    else if (IsVideoInputMediaType(device.type))
       video_devices.push_back(device);
     else
       NOTREACHED();
@@ -1693,7 +1661,7 @@ void MediaStreamManager::HandleAccessRequestResponse(
     DVLOG(1) << "Set no audio found label " << label;
   }
 
-  if (!found_video && IsVideoMediaType(request->video_type()))
+  if (!found_video && IsVideoInputMediaType(request->video_type()))
     request->SetState(request->video_type(), MEDIA_REQUEST_STATE_ERROR);
 
   if (RequestDone(*request))
@@ -1751,7 +1719,7 @@ void MediaStreamManager::NotifyDevicesChanged(
         new_devices);
     if (media_observer)
       media_observer->OnAudioCaptureDevicesChanged();
-  } else if (IsVideoMediaType(stream_type)) {
+  } else if (IsVideoInputMediaType(stream_type)) {
     MediaCaptureDevicesImpl::GetInstance()->OnVideoCaptureDevicesChanged(
         new_devices);
     if (media_observer)
@@ -1765,7 +1733,7 @@ bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   const bool requested_audio = IsAudioInputMediaType(request.audio_type());
-  const bool requested_video = IsVideoMediaType(request.video_type());
+  const bool requested_video = IsVideoInputMediaType(request.video_type());
 
   const bool audio_done =
       !requested_audio ||
@@ -1786,7 +1754,7 @@ bool MediaStreamManager::RequestDone(const DeviceRequest& request) const {
 
 MediaStreamProvider* MediaStreamManager::GetDeviceManager(
     MediaStreamType stream_type) {
-  if (IsVideoMediaType(stream_type))
+  if (IsVideoInputMediaType(stream_type))
     return video_capture_manager();
   else if (IsAudioInputMediaType(stream_type))
     return audio_input_device_manager();

content/browser/renderer_host/media/media_stream_ui_proxy.cc

@@ -324,9 +324,8 @@ void FakeMediaStreamUIProxy::RequestAccess(
          request->requested_audio_device_id == it->id)) {
       devices_to_use.push_back(*it);
       accepted_audio = true;
-    } else if (!accepted_video &&
-               IsVideoMediaType(request->video_type) &&
-               IsVideoMediaType(it->type) &&
+    } else if (!accepted_video && IsVideoInputMediaType(request->video_type) &&
+               IsVideoInputMediaType(it->type) &&
                (request->requested_video_device_id.empty() ||
                 request->requested_video_device_id == it->id)) {
       devices_to_use.push_back(*it);

content/common/media/media_stream.mojom

@@ -45,7 +45,7 @@ enum MediaStreamRequestResult {
 // See content/common/media/media_stream_controls.h.
 struct TrackControls {
   bool requested;
-  string stream_source;
+  MediaStreamType stream_type;
   string device_id;
 };
 

content/common/media/media_stream_controls.cc

@@ -6,14 +6,10 @@
 
 namespace content {
 
-const char kMediaStreamSourceTab[] = "tab";
-const char kMediaStreamSourceScreen[] = "screen";
-const char kMediaStreamSourceDesktop[] = "desktop";
-const char kMediaStreamSourceSystem[] = "system";
-
 TrackControls::TrackControls() {}
 
-TrackControls::TrackControls(bool request) : requested(request) {}
+TrackControls::TrackControls(bool request, MediaStreamType type)
+    : requested(request), stream_type(type) {}
 
 TrackControls::TrackControls(const TrackControls& other) = default;
 
@@ -22,7 +18,10 @@ TrackControls::~TrackControls() {}
 StreamControls::StreamControls() {}
 
 StreamControls::StreamControls(bool request_audio, bool request_video)
-    : audio(request_audio), video(request_video) {}
+    : audio(request_audio,
+            request_audio ? MEDIA_DEVICE_AUDIO_CAPTURE : MEDIA_NO_SERVICE),
+      video(request_video,
+            request_video ? MEDIA_DEVICE_VIDEO_CAPTURE : MEDIA_NO_SERVICE) {}
 
 StreamControls::~StreamControls() {}
 

content/common/media/media_stream_controls.h

@@ -8,28 +8,27 @@
 #include <string>
 
 #include "content/common/content_export.h"
+#include "content/public/common/media_stream_request.h"
 
 namespace content {
 
 // Names for media stream source capture types.
-// These are values of the "TrackControls.stream_source" field, and are
-// set via the "chromeMediaSource" constraint.
+// These are values set via the "chromeMediaSource" constraint.
 CONTENT_EXPORT extern const char kMediaStreamSourceTab[];
-CONTENT_EXPORT extern const char kMediaStreamSourceScreen[];
+CONTENT_EXPORT extern const char kMediaStreamSourceScreen[]; /* video only */
 CONTENT_EXPORT extern const char kMediaStreamSourceDesktop[];
-CONTENT_EXPORT extern const char kMediaStreamSourceSystem[];
+CONTENT_EXPORT extern const char kMediaStreamSourceSystem[]; /* audio only */
 
 struct CONTENT_EXPORT TrackControls {
   TrackControls();
-  explicit TrackControls(bool request);
+  explicit TrackControls(bool request, MediaStreamType type);
   explicit TrackControls(const TrackControls& other);
   ~TrackControls();
 
   bool requested = false;
 
-  // Source. This is "tab", "screen", "desktop", "system", or blank.
-  // Consider replacing with MediaStreamType enum variables.
-  std::string stream_source;  // audio.kMediaStreamSource
+  // Represents the requested  stream type.
+  MediaStreamType stream_type = MEDIA_NO_SERVICE;
 
   // An empty string represents the default device.
   // A nonempty string represents a specific device.

content/common/media/media_stream_typemap_traits.cc

@@ -187,7 +187,7 @@ bool StructTraits<
     content::TrackControls>::Read(content::mojom::TrackControlsDataView input,
                                   content::TrackControls* out) {
   out->requested = input.requested();
-  if (!input.ReadStreamSource(&out->stream_source))
+  if (!input.ReadStreamType(&out->stream_type))
     return false;
   if (!input.ReadDeviceId(&out->device_id))
     return false;

content/common/media/media_stream_typemap_traits.h

@@ -36,9 +36,9 @@ struct StructTraits<content::mojom::TrackControlsDataView,
     return controls.requested;
   }
 
-  static const std::string& stream_source(
+  static const content::MediaStreamType& stream_type(
       const content::TrackControls& controls) {
-    return controls.stream_source;
+    return controls.stream_type;
   }
 
   static const std::string& device_id(const content::TrackControls& controls) {
@@ -76,4 +76,4 @@ struct StructTraits<content::mojom::StreamControlsDataView,
 
 }  // namespace mojo
 
-#endif  // CONTENT_COMMON_MEDIA_MEDIA_STREAM_TYPEMAP_TRAITS_H_
+#endif  // CONTENT_COMMON_MEDIA_MEDIA_STREAM_TYPEMAP_TRAITS_H_
\ No newline at end of file

content/public/common/media_stream_request.cc

@@ -15,7 +15,7 @@ bool IsAudioInputMediaType(MediaStreamType type) {
           type == MEDIA_DESKTOP_AUDIO_CAPTURE);
 }
 
-bool IsVideoMediaType(MediaStreamType type) {
+bool IsVideoInputMediaType(MediaStreamType type) {
   return (type == MEDIA_DEVICE_VIDEO_CAPTURE ||
           type == MEDIA_TAB_VIDEO_CAPTURE ||
           type == MEDIA_DESKTOP_VIDEO_CAPTURE);
@@ -27,6 +27,11 @@ bool IsScreenCaptureMediaType(MediaStreamType type) {
           type == MEDIA_DESKTOP_VIDEO_CAPTURE);
 }
 
+bool IsDeviceMediaType(MediaStreamType type) {
+  return (type == MEDIA_DEVICE_AUDIO_CAPTURE ||
+          type == MEDIA_DEVICE_VIDEO_CAPTURE);
+}
+
 // static
 const int MediaStreamDevice::kNoId = -1;
 

content/public/common/media_stream_request.h

@@ -77,8 +77,9 @@ using CameraCalibration =
 // Convenience predicates to determine whether the given type represents some
 // audio or some video device.
 CONTENT_EXPORT bool IsAudioInputMediaType(MediaStreamType type);
-CONTENT_EXPORT bool IsVideoMediaType(MediaStreamType type);
+CONTENT_EXPORT bool IsVideoInputMediaType(MediaStreamType type);
 CONTENT_EXPORT bool IsScreenCaptureMediaType(MediaStreamType type);
+CONTENT_EXPORT bool IsDeviceMediaType(MediaStreamType type);
 
 // TODO(xians): Change the structs to classes.
 // Represents one device in a request for media stream(s).

content/renderer/media/stream/media_stream_constraints_util_audio_unittest.cc

@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "base/message_loop/message_loop.h"
-#include "content/common/media/media_stream_controls.h"
 #include "content/renderer/media/stream/local_media_stream_audio_source.h"
 #include "content/renderer/media/stream/media_stream_audio_source.h"
 #include "content/renderer/media/stream/media_stream_source.h"

content/renderer/media/stream/media_stream_constraints_util_video_content.cc

@@ -260,7 +260,7 @@ int ClampToValidScreenCastDimension(int value) {
 VideoCaptureSettings SelectResultFromCandidates(
     const VideoContentCaptureCandidates& candidates,
     const blink::WebMediaTrackConstraintSet& basic_constraint_set,
-    const std::string& stream_source,
+    MediaStreamType stream_type,
     int screen_width,
     int screen_height) {
   std::string device_id = SelectDeviceIDFromCandidates(
@@ -300,7 +300,7 @@ VideoCaptureSettings SelectResultFromCandidates(
 
   // This default comes from the old algorithm.
   media::ResolutionChangePolicy default_resolution_policy =
-      stream_source == kMediaStreamSourceTab
+      stream_type == MEDIA_TAB_VIDEO_CAPTURE
           ? media::ResolutionChangePolicy::FIXED_RESOLUTION
           : media::ResolutionChangePolicy::ANY_WITHIN_LIMIT;
 
@@ -346,7 +346,7 @@ VideoCaptureSettings UnsatisfiedConstraintsResult(
 
 VideoCaptureSettings SelectSettingsVideoContentCapture(
     const blink::WebMediaConstraints& constraints,
-    const std::string& stream_source,
+    MediaStreamType stream_type,
     int screen_width,
     int screen_height) {
   VideoContentCaptureCandidates candidates;
@@ -367,7 +367,7 @@ VideoCaptureSettings SelectSettingsVideoContentCapture(
 
   DCHECK(!candidates.IsEmpty());
   return SelectResultFromCandidates(candidates, constraints.Basic(),
-                                    stream_source, screen_width, screen_height);
+                                    stream_type, screen_width, screen_height);
 }
 
 }  // namespace content

content/renderer/media/stream/media_stream_constraints_util_video_content.h

@@ -8,6 +8,7 @@
 #include <string>
 
 #include "content/common/content_export.h"
+#include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/stream/media_stream_constraints_util.h"
 
 namespace blink {
@@ -28,7 +29,7 @@ CONTENT_EXPORT extern const double kDefaultScreenCastFrameRate;
 // for content video capture based on the given |constraints|.
 VideoCaptureSettings CONTENT_EXPORT
 SelectSettingsVideoContentCapture(const blink::WebMediaConstraints& constraints,
-                                  const std::string& stream_source,
+                                  MediaStreamType stream_type,
                                   int screen_width,
                                   int screen_height);
 

content/renderer/media/stream/media_stream_constraints_util_video_content_unittest.cc

@@ -7,7 +7,7 @@
 #include <cmath>
 #include <string>
 
-#include "content/common/media/media_stream_controls.h"
+#include "content/renderer/media/stream/media_stream_source.h"
 #include "content/renderer/media/stream/mock_constraint_factory.h"
 #include "media/base/limits.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -60,11 +60,10 @@ void CheckTrackAdapterSettingsEqualsFormatDefaultAspectRatio(
 class MediaStreamConstraintsUtilVideoContentTest : public testing::Test {
  protected:
   VideoCaptureSettings SelectSettings(
-      const std::string& stream_source =
-          std::string(kMediaStreamSourceScreen)) {
+      MediaStreamType stream_type = MEDIA_DESKTOP_VIDEO_CAPTURE) {
     blink::WebMediaConstraints constraints =
         constraint_factory_.CreateWebMediaConstraints();
-    return SelectSettingsVideoContentCapture(constraints, stream_source,
+    return SelectSettingsVideoContentCapture(constraints, stream_type,
                                              kDefaultScreenCastWidth,
                                              kDefaultScreenCastHeight);
   }
@@ -2035,7 +2034,7 @@ TEST_F(MediaStreamConstraintsUtilVideoContentTest, ResolutionChangePolicy) {
   }
   {
     constraint_factory_.Reset();
-    auto result = SelectSettings(kMediaStreamSourceTab);
+    auto result = SelectSettings(MEDIA_TAB_VIDEO_CAPTURE);
     EXPECT_EQ(kDefaultScreenCastWidth, result.Width());
     EXPECT_EQ(kDefaultScreenCastHeight, result.Height());
     // Default policy for tab capture is fixed resolution.

content/renderer/media/stream/media_stream_device_observer.cc

@@ -133,7 +133,7 @@ void MediaStreamDeviceObserver::AddStream(const std::string& label,
   Stream stream;
   if (IsAudioInputMediaType(device.type))
     stream.audio_devices.push_back(device);
-  else if (IsVideoMediaType(device.type))
+  else if (IsVideoInputMediaType(device.type))
     stream.video_devices.push_back(device);
   else
     NOTREACHED();

content/renderer/media/stream/media_stream_source.cc

@@ -9,6 +9,11 @@
 
 namespace content {
 
+const char kMediaStreamSourceTab[] = "tab";
+const char kMediaStreamSourceScreen[] = "screen";
+const char kMediaStreamSourceDesktop[] = "desktop";
+const char kMediaStreamSourceSystem[] = "system";
+
 const char MediaStreamSource::kSourceId[] = "sourceId";
 
 MediaStreamSource::MediaStreamSource() {

content/renderer/media/stream/media_stream_source.h

@@ -14,6 +14,13 @@
 
 namespace content {
 
+// Names for media stream source capture types.
+// These are values set via the "chromeMediaSource" constraint.
+CONTENT_EXPORT extern const char kMediaStreamSourceTab[];
+CONTENT_EXPORT extern const char kMediaStreamSourceScreen[]; /* video only */
+CONTENT_EXPORT extern const char kMediaStreamSourceDesktop[];
+CONTENT_EXPORT extern const char kMediaStreamSourceSystem[]; /* audio only */
+
 class CONTENT_EXPORT MediaStreamSource
     : public blink::WebMediaStreamSource::ExtraData {
  public:

content/renderer/media/stream/user_media_processor.cc

@@ -18,6 +18,7 @@
 #include "base/task_runner_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/common/media/media_stream_controls.h"
+#include "content/public/common/media_stream_request.h"
 #include "content/renderer/media/stream/local_media_stream_audio_source.h"
 #include "content/renderer/media/stream/media_stream_audio_processor.h"
 #include "content/renderer/media/stream/media_stream_audio_source.h"
@@ -53,22 +54,56 @@ using EchoCancellationType = AudioProcessingProperties::EchoCancellationType;
 
 namespace {
 
-void CopyFirstString(const blink::StringConstraint& constraint,
-                     std::string* destination) {
-  if (!constraint.Exact().IsEmpty())
-    *destination = constraint.Exact()[0].Utf8();
-}
+void InitializeAudioTrackControls(const blink::WebUserMediaRequest& web_request,
+                                  TrackControls* track_controls) {
+  const blink::WebMediaConstraints& constraints =
+      web_request.AudioConstraints();
+  DCHECK(!constraints.IsNull());
+  track_controls->requested = true;
 
-bool IsDeviceSource(const std::string& source) {
-  return source.empty();
+  MediaStreamType* stream_type = &track_controls->stream_type;
+  *stream_type = MEDIA_NO_SERVICE;
+
+  std::string source_constraint =
+      constraints.Basic().media_stream_source.Exact().IsEmpty()
+          ? std::string()
+          : constraints.Basic().media_stream_source.Exact()[0].Utf8();
+  if (!source_constraint.empty()) {
+    if (source_constraint == kMediaStreamSourceTab) {
+      *stream_type = MEDIA_TAB_AUDIO_CAPTURE;
+    } else if (source_constraint == kMediaStreamSourceDesktop ||
+               source_constraint == kMediaStreamSourceSystem) {
+      *stream_type = MEDIA_DESKTOP_AUDIO_CAPTURE;
+    }
+  } else {
+    *stream_type = MEDIA_DEVICE_AUDIO_CAPTURE;
+  }
 }
 
-void InitializeTrackControls(const blink::WebMediaConstraints& constraints,
-                             TrackControls* track_controls) {
+void InitializeVideoTrackControls(const blink::WebUserMediaRequest& web_request,
+                                  TrackControls* track_controls) {
+  const blink::WebMediaConstraints& constraints =
+      web_request.VideoConstraints();
   DCHECK(!constraints.IsNull());
   track_controls->requested = true;
-  CopyFirstString(constraints.Basic().media_stream_source,
-                  &track_controls->stream_source);
+
+  MediaStreamType* stream_type = &track_controls->stream_type;
+  *stream_type = MEDIA_NO_SERVICE;
+
+  std::string source_constraint =
+      constraints.Basic().media_stream_source.Exact().IsEmpty()
+          ? std::string()
+          : constraints.Basic().media_stream_source.Exact()[0].Utf8();
+  if (!source_constraint.empty()) {
+    if (source_constraint == kMediaStreamSourceTab) {
+      *stream_type = MEDIA_TAB_VIDEO_CAPTURE;
+    } else if (source_constraint == kMediaStreamSourceDesktop ||
+               source_constraint == kMediaStreamSourceScreen) {
+      *stream_type = MEDIA_DESKTOP_VIDEO_CAPTURE;
+    }
+  } else {
+    *stream_type = MEDIA_DEVICE_VIDEO_CAPTURE;
+  }
 }
 
 bool IsSameDevice(const MediaStreamDevice& device,
@@ -90,18 +125,6 @@ bool IsSameSource(const blink::WebMediaStreamSource& source,
   return IsSameDevice(device, other_device);
 }
 
-bool IsValidAudioContentSource(const std::string& source) {
-  return source == kMediaStreamSourceTab ||
-         source == kMediaStreamSourceDesktop ||
-         source == kMediaStreamSourceSystem;
-}
-
-bool IsValidVideoContentSource(const std::string& source) {
-  return source == kMediaStreamSourceTab ||
-         source == kMediaStreamSourceDesktop ||
-         source == kMediaStreamSourceScreen;
-}
-
 void SurfaceAudioProcessingSettings(blink::WebMediaStreamSource* source) {
   MediaStreamAudioSource* source_impl =
       static_cast<MediaStreamAudioSource*>(source->GetExtraData());
@@ -432,14 +455,14 @@ void UserMediaProcessor::SetupAudioInput() {
   DCHECK(current_request_info_->web_request().Audio());
 
   auto& audio_controls = current_request_info_->stream_controls()->audio;
-  InitializeTrackControls(
-      current_request_info_->web_request().AudioConstraints(), &audio_controls);
-  if (IsDeviceSource(audio_controls.stream_source)) {
+  InitializeAudioTrackControls(current_request_info_->web_request(),
+                               &audio_controls);
+  if (IsDeviceMediaType(audio_controls.stream_type)) {
     GetMediaDevicesDispatcher()->GetAudioInputCapabilities(base::BindOnce(
         &UserMediaProcessor::SelectAudioDeviceSettings,
         weak_factory_.GetWeakPtr(), current_request_info_->web_request()));
   } else {
-    if (!IsValidAudioContentSource(audio_controls.stream_source)) {
+    if (!IsAudioInputMediaType(audio_controls.stream_type)) {
       blink::WebString failed_constraint_name =
           blink::WebString::FromASCII(current_request_info_->web_request()
                                           .AudioConstraints()
@@ -516,8 +539,8 @@ void UserMediaProcessor::SelectAudioSettings(
       settings.hotword_enabled();
   current_request_info_->SetAudioCaptureSettings(
       settings,
-      !IsDeviceSource(
-          current_request_info_->stream_controls()->audio.stream_source));
+      !IsDeviceMediaType(
+          current_request_info_->stream_controls()->audio.stream_type));
 
   // No further audio setup required. Continue with video.
   SetupVideoInput();
@@ -532,14 +555,14 @@ void UserMediaProcessor::SetupVideoInput() {
     return;
   }
   auto& video_controls = current_request_info_->stream_controls()->video;
-  InitializeTrackControls(
-      current_request_info_->web_request().VideoConstraints(), &video_controls);
-  if (IsDeviceSource(video_controls.stream_source)) {
+  InitializeVideoTrackControls(current_request_info_->web_request(),
+                               &video_controls);
+  if (IsDeviceMediaType(video_controls.stream_type)) {
     GetMediaDevicesDispatcher()->GetVideoInputCapabilities(base::BindOnce(
         &UserMediaProcessor::SelectVideoDeviceSettings,
         weak_factory_.GetWeakPtr(), current_request_info_->web_request()));
   } else {
-    if (!IsValidVideoContentSource(video_controls.stream_source)) {
+    if (!IsVideoInputMediaType(video_controls.stream_type)) {
       blink::WebString failed_constraint_name =
           blink::WebString::FromASCII(current_request_info_->web_request()
                                           .VideoConstraints()
@@ -565,8 +588,8 @@ void UserMediaProcessor::SelectVideoDeviceSettings(
     return;
 
   DCHECK(current_request_info_->stream_controls()->video.requested);
-  DCHECK(IsDeviceSource(
-      current_request_info_->stream_controls()->video.stream_source));
+  DCHECK(IsDeviceMediaType(
+      current_request_info_->stream_controls()->video.stream_type));
 
   VideoDeviceCaptureCapabilities capabilities;
   capabilities.device_capabilities = std::move(video_input_capabilities);
@@ -605,7 +628,7 @@ void UserMediaProcessor::SelectVideoContentSettings() {
   gfx::Size screen_size = GetScreenSize();
   VideoCaptureSettings settings = SelectSettingsVideoContentCapture(
       current_request_info_->web_request().VideoConstraints(),
-      current_request_info_->stream_controls()->video.stream_source,
+      current_request_info_->stream_controls()->video.stream_type,
       screen_size.width(), screen_size.height());
   if (!settings.HasValue()) {
     blink::WebString failed_constraint_name =