OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "content/renderer/media/remote_media_stream_impl.h" | |
6 | |
7 #include <string> | |
8 | |
9 #include "base/logging.h" | |
10 #include "base/utf_string_conversions.h" | |
11 #include "content/renderer/media/media_stream_extra_data.h" | |
12 #include "third_party/WebKit/Source/Platform/chromium/public/WebString.h" | |
13 | |
14 namespace content { | |
15 | |
16 // RemoteMediaStreamTrackObserver is responsible for listening on change | |
17 // notification on a remote webrtc MediaStreamTrack and notify WebKit. | |
18 class RemoteMediaStreamTrackObserver | |
19 : NON_EXPORTED_BASE(public webrtc::ObserverInterface), | |
20 NON_EXPORTED_BASE(public base::NonThreadSafe) { | |
21 public: | |
22 RemoteMediaStreamTrackObserver( | |
23 webrtc::MediaStreamTrackInterface* webrtc_track, | |
24 const WebKit::WebMediaStreamTrack& webkit_track); | |
25 virtual ~RemoteMediaStreamTrackObserver(); | |
26 | |
27 webrtc::MediaStreamTrackInterface* observered_track() { | |
28 return webrtc_track_; | |
29 } | |
30 const WebKit::WebMediaStreamTrack& webkit_track() { return webkit_track_; } | |
31 | |
32 // webrtc::ObserverInterface implementation. | |
33 virtual void OnChanged() OVERRIDE; | |
tommi (sloooow) - chröme
2013/04/16 15:59:59
make private?
perkj_chrome
2013/04/18 14:46:58
Done.
| |
34 | |
35 private: | |
36 webrtc::MediaStreamTrackInterface::TrackState state_; | |
37 scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track_; | |
38 WebKit::WebMediaStreamTrack webkit_track_; | |
39 | |
40 DISALLOW_COPY_AND_ASSIGN(RemoteMediaStreamTrackObserver); | |
41 }; | |
42 | |
43 RemoteMediaStreamTrackObserver::RemoteMediaStreamTrackObserver( | |
44 webrtc::MediaStreamTrackInterface* webrtc_track, | |
45 const WebKit::WebMediaStreamTrack& webkit_track) | |
46 : state_(webrtc_track->state()), | |
47 webrtc_track_(webrtc_track), | |
48 webkit_track_(webkit_track) { | |
49 webrtc_track->RegisterObserver(this); | |
50 } | |
51 | |
52 RemoteMediaStreamTrackObserver::~RemoteMediaStreamTrackObserver() { | |
53 webrtc_track_->UnregisterObserver(this); | |
54 } | |
55 | |
56 void RemoteMediaStreamTrackObserver::OnChanged() { | |
57 DCHECK(CalledOnValidThread()); | |
58 | |
59 webrtc::MediaStreamTrackInterface::TrackState state = webrtc_track_->state(); | |
60 if (state == state_) | |
61 return; | |
62 state_ = state; | |
tommi (sloooow) - chröme
2013/04/16 15:59:59
nit: empty line above
perkj_chrome
2013/04/18 14:46:58
Done.
| |
63 | |
64 switch (state) { | |
65 case webrtc::MediaStreamTrackInterface::kInitializing: | |
66 /* kInitializing is not ready state. */ | |
tommi (sloooow) - chröme
2013/04/16 15:59:59
//
I'm not sure what this comment means though?
perkj_chrome
2013/04/18 14:46:58
Done.
| |
67 break; | |
68 case webrtc::MediaStreamTrackInterface::kLive: | |
69 webkit_track_.source().setReadyState( | |
70 WebKit::WebMediaStreamSource::ReadyStateLive); | |
71 break; | |
72 case webrtc::MediaStreamTrackInterface::kEnded: | |
73 webkit_track_.source().setReadyState( | |
74 WebKit::WebMediaStreamSource::ReadyStateEnded); | |
75 break; | |
76 default: | |
77 NOTREACHED(); | |
tommi (sloooow) - chröme
2013/04/16 15:59:59
nit: add a break;
perkj_chrome
2013/04/18 14:46:58
Done.
| |
78 } | |
79 } | |
80 | |
81 static void InitializeWebkitTrack( | |
tommi (sloooow) - chröme
2013/04/16 15:59:59
should this be in anonymous namespace near the top
perkj_chrome
2013/04/18 14:46:58
I use RemoteMediaStreamTrackObserver in FindTrackO
| |
82 webrtc::MediaStreamTrackInterface* track, | |
83 WebKit::WebMediaStreamTrack* webkit_track, | |
84 WebKit::WebMediaStreamSource::Type type) { | |
85 WebKit::WebMediaStreamSource webkit_source; | |
86 WebKit::WebString webkit_track_id(UTF8ToUTF16(track->id())); | |
87 | |
88 webkit_source.initialize(webkit_track_id, type, webkit_track_id); | |
89 webkit_track->initialize(webkit_track_id, webkit_source); | |
90 } | |
91 | |
92 static content::RemoteMediaStreamTrackObserver* FindTrackObserver( | |
93 webrtc::MediaStreamTrackInterface* track, | |
94 const ScopedVector<content::RemoteMediaStreamTrackObserver>& observers) { | |
95 ScopedVector<content::RemoteMediaStreamTrackObserver>::const_iterator it = | |
96 observers.begin(); | |
97 for (; it != observers.end(); ++it) { | |
98 if ((*it)->observered_track() == track) { | |
tommi (sloooow) - chröme
2013/04/16 15:59:59
nit: no {}
perkj_chrome
2013/04/18 14:46:58
Done.
| |
99 return *it; | |
100 } | |
101 } | |
102 return NULL; | |
103 } | |
104 | |
105 RemoteMediaStreamImpl::RemoteMediaStreamImpl( | |
106 webrtc::MediaStreamInterface* webrtc_stream) | |
107 : webrtc_stream_(webrtc_stream) { | |
108 webrtc_stream_->RegisterObserver(this); | |
109 | |
110 webrtc::AudioTrackVector webrtc_audio_tracks = | |
111 webrtc_stream_->GetAudioTracks(); | |
112 WebKit::WebVector<WebKit::WebMediaStreamTrack> webkit_audio_tracks( | |
113 webrtc_audio_tracks.size()); | |
114 | |
115 // Initialize WebKit audio tracks. | |
116 size_t i = 0; | |
117 for (; i < webrtc_audio_tracks.size(); ++i) { | |
118 webrtc::AudioTrackInterface* audio_track = webrtc_audio_tracks[i]; | |
119 DCHECK(audio_track); | |
120 InitializeWebkitTrack(audio_track, &webkit_audio_tracks[i], | |
121 WebKit::WebMediaStreamSource::TypeAudio); | |
122 audio_track_observers_.push_back( | |
123 new RemoteMediaStreamTrackObserver(audio_track, | |
124 webkit_audio_tracks[i])); | |
125 } | |
126 | |
127 // Initialize WebKit video tracks. | |
128 webrtc::VideoTrackVector webrtc_video_tracks = | |
129 webrtc_stream_->GetVideoTracks(); | |
130 WebKit::WebVector<WebKit::WebMediaStreamTrack> webkit_video_tracks( | |
131 webrtc_video_tracks.size()); | |
132 for (i = 0; i < webrtc_video_tracks.size(); ++i) { | |
133 webrtc::VideoTrackInterface* video_track = webrtc_video_tracks[i]; | |
134 DCHECK(video_track); | |
135 InitializeWebkitTrack(video_track, &webkit_video_tracks[i], | |
136 WebKit::WebMediaStreamSource::TypeVideo); | |
137 video_track_observers_.push_back( | |
138 new RemoteMediaStreamTrackObserver(video_track, | |
139 webkit_video_tracks[i])); | |
140 } | |
141 | |
142 webkit_stream_.initialize(UTF8ToUTF16(webrtc_stream->label()), | |
143 webkit_audio_tracks, webkit_video_tracks); | |
144 webkit_stream_.setExtraData(new MediaStreamExtraData(webrtc_stream, false)); | |
145 } | |
146 | |
147 RemoteMediaStreamImpl::~RemoteMediaStreamImpl() { | |
148 webrtc_stream_->UnregisterObserver(this); | |
149 } | |
150 | |
151 void RemoteMediaStreamImpl::OnChanged() { | |
152 // Find removed audio tracks. | |
153 ScopedVector<RemoteMediaStreamTrackObserver>::iterator audio_it = | |
154 audio_track_observers_.begin(); | |
155 while (audio_it != audio_track_observers_.end()) { | |
156 std::string track_id = (*audio_it)->observered_track()->id(); | |
157 if (webrtc_stream_->FindAudioTrack(track_id) == NULL) { | |
158 webkit_stream_.removeTrack((*audio_it)->webkit_track()); | |
159 audio_it = audio_track_observers_.erase(audio_it); | |
160 } else { | |
161 ++audio_it; | |
162 } | |
163 } | |
164 | |
165 // Find removed video tracks. | |
166 ScopedVector<RemoteMediaStreamTrackObserver>::iterator video_it = | |
167 video_track_observers_.begin(); | |
168 while (video_it != video_track_observers_.end()) { | |
169 std::string track_id = (*video_it)->observered_track()->id(); | |
170 if (webrtc_stream_->FindVideoTrack(track_id) == NULL) { | |
171 webkit_stream_.removeTrack((*video_it)->webkit_track()); | |
172 video_it = video_track_observers_.erase(video_it); | |
173 } else { | |
174 ++video_it; | |
175 } | |
176 } | |
177 | |
178 // Find added audio tracks. | |
179 webrtc::AudioTrackVector webrtc_audio_tracks = | |
180 webrtc_stream_->GetAudioTracks(); | |
181 for (webrtc::AudioTrackVector::iterator it = webrtc_audio_tracks.begin(); | |
182 it != webrtc_audio_tracks.end(); ++it) { | |
183 if (!FindTrackObserver(*it, audio_track_observers_)) { | |
184 WebKit::WebMediaStreamTrack new_track; | |
185 InitializeWebkitTrack(*it, &new_track, | |
186 WebKit::WebMediaStreamSource::TypeAudio); | |
187 audio_track_observers_.push_back( | |
188 new RemoteMediaStreamTrackObserver(*it, new_track)); | |
189 webkit_stream_.addTrack(new_track); | |
190 } | |
191 } | |
192 | |
193 // Find added video tracks. | |
194 webrtc::VideoTrackVector webrtc_video_tracks = | |
195 webrtc_stream_->GetVideoTracks(); | |
196 for (webrtc::VideoTrackVector::iterator it = webrtc_video_tracks.begin(); | |
197 it != webrtc_video_tracks.end(); ++it) { | |
198 if (!FindTrackObserver(*it, video_track_observers_)) { | |
199 WebKit::WebMediaStreamTrack new_track; | |
200 InitializeWebkitTrack(*it, &new_track, | |
201 WebKit::WebMediaStreamSource::TypeVideo); | |
202 video_track_observers_.push_back( | |
203 new RemoteMediaStreamTrackObserver(*it, new_track)); | |
204 webkit_stream_.addTrack(new_track); | |
205 } | |
206 } | |
207 } | |
208 | |
209 } // namespace content | |
OLD | NEW |