1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/modules/mediastream/media_stream_track.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_stream_constraints.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_media_stream_track_state.h"
#include "third_party/blink/renderer/core/frame/local_dom_window.h"
#include "third_party/blink/renderer/modules/mediastream/media_constraints_impl.h"
#include "third_party/blink/renderer/modules/mediastream/media_stream_track_video_stats.h"
#include "third_party/blink/renderer/modules/mediastream/transferred_media_stream_track.h"
#include "third_party/blink/renderer/modules/mediastream/user_media_client.h"
#include "third_party/blink/renderer/modules/mediastream/user_media_request.h"
namespace blink {
namespace {
class GetOpenDeviceRequestCallbacks final : public UserMediaRequest::Callbacks {
public:
~GetOpenDeviceRequestCallbacks() override = default;
void OnSuccess(const MediaStreamVector& streams,
CaptureController* capture_controller) override {}
void OnError(ScriptWrappable* callback_this_value,
const V8MediaStreamError* error,
CaptureController* capture_controller,
UserMediaRequestResult result) override {}
};
} // namespace
MediaStreamTrack::MediaStreamTrack()
: ActiveScriptWrappable<MediaStreamTrack>({}) {}
String ContentHintToString(
const WebMediaStreamTrack::ContentHintType& content_hint) {
switch (content_hint) {
case WebMediaStreamTrack::ContentHintType::kNone:
return kContentHintStringNone;
case WebMediaStreamTrack::ContentHintType::kAudioSpeech:
return kContentHintStringAudioSpeech;
case WebMediaStreamTrack::ContentHintType::kAudioMusic:
return kContentHintStringAudioMusic;
case WebMediaStreamTrack::ContentHintType::kVideoMotion:
return kContentHintStringVideoMotion;
case WebMediaStreamTrack::ContentHintType::kVideoDetail:
return kContentHintStringVideoDetail;
case WebMediaStreamTrack::ContentHintType::kVideoText:
return kContentHintStringVideoText;
}
NOTREACHED();
}
V8MediaStreamTrackState ReadyStateToV8TrackState(
const MediaStreamSource::ReadyState& ready_state) {
// Although muted is tracked as a ReadyState, only "live" and "ended" are
// visible externally.
switch (ready_state) {
case MediaStreamSource::kReadyStateLive:
case MediaStreamSource::kReadyStateMuted:
return V8MediaStreamTrackState(V8MediaStreamTrackState::Enum::kLive);
case MediaStreamSource::kReadyStateEnded:
return V8MediaStreamTrackState(V8MediaStreamTrackState::Enum::kEnded);
}
NOTREACHED();
}
// static
MediaStreamTrack* MediaStreamTrack::FromTransferredState(
ScriptState* script_state,
const TransferredValues& data) {
DCHECK(data.track_impl_subtype);
// Allow injecting a mock.
if (GetFromTransferredStateImplForTesting()) {
return GetFromTransferredStateImplForTesting().Run(data);
}
auto* window =
DynamicTo<LocalDOMWindow>(ExecutionContext::From(script_state));
if (!window) {
return nullptr;
}
UserMediaClient* user_media_client = UserMediaClient::From(window);
if (!user_media_client) {
return nullptr;
}
// TODO(1288839): Set media_type, options, callbacks, surface appropriately
MediaConstraints audio = (data.kind == "audio")
? media_constraints_impl::Create()
: MediaConstraints();
MediaConstraints video = (data.kind == "video")
? media_constraints_impl::Create()
: MediaConstraints();
UserMediaRequest* const request = MakeGarbageCollected<UserMediaRequest>(
window, user_media_client, UserMediaRequestType::kDisplayMedia, audio,
video, /*should_prefer_current_tab=*/false,
/*capture_controller=*/nullptr,
MakeGarbageCollected<GetOpenDeviceRequestCallbacks>(),
IdentifiableSurface());
if (!request) {
return nullptr;
}
// TODO(1288839): Create a TransferredMediaStreamTrack implementing interfaces
// supporting BrowserCaptureMediaStreamTrack operations when needed (or
// support these behaviors in some other way).
TransferredMediaStreamTrack* transferred_media_stream_track =
MakeGarbageCollected<TransferredMediaStreamTrack>(
ExecutionContext::From(script_state), data);
request->SetTransferData(data.session_id, data.transfer_id,
transferred_media_stream_track);
request->Start();
// TODO(1288839): get rid of TransferredMediaStreamTrack, since it's just a
// container for the impl track
auto* track = transferred_media_stream_track->track();
// TODO(1288839): What happens if GetOpenDevice fails?
DCHECK(track);
if (track->GetWrapperTypeInfo() != data.track_impl_subtype) {
NOTREACHED() << "transferred track should be "
<< data.track_impl_subtype->interface_name
<< " but instead it is "
<< track->GetWrapperTypeInfo()->interface_name;
}
return track;
}
// static
MediaStreamTrack::FromTransferredStateImplForTesting&
MediaStreamTrack::GetFromTransferredStateImplForTesting() {
static base::NoDestructor<
MediaStreamTrack::FromTransferredStateImplForTesting>
impl;
return *impl;
}
} // namespace blink
|
