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 { | |
tommi (sloooow) - chröme
2013/04/18 16:33:31
only one space (looks like an accidental change)
perkj_chrome
2013/04/19 06:23:21
Done.
| |
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 private: | |
33 // webrtc::ObserverInterface implementation. | |
34 virtual void OnChanged() OVERRIDE; | |
35 | |
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 } // namespace content | |
44 | |
45 namespace { | |
46 | |
47 void InitializeWebkitTrack(webrtc::MediaStreamTrackInterface* track, | |
48 WebKit::WebMediaStreamTrack* webkit_track, | |
49 WebKit::WebMediaStreamSource::Type type) { | |
50 WebKit::WebMediaStreamSource webkit_source; | |
51 WebKit::WebString webkit_track_id(UTF8ToUTF16(track->id())); | |
52 | |
53 webkit_source.initialize(webkit_track_id, type, webkit_track_id); | |
54 webkit_track->initialize(webkit_track_id, webkit_source); | |
55 } | |
56 | |
57 content::RemoteMediaStreamTrackObserver* FindTrackObserver( | |
58 webrtc::MediaStreamTrackInterface* track, | |
59 const ScopedVector<content::RemoteMediaStreamTrackObserver>& observers) { | |
60 ScopedVector<content::RemoteMediaStreamTrackObserver>::const_iterator it = | |
61 observers.begin(); | |
62 for (; it != observers.end(); ++it) { | |
63 if ((*it)->observered_track() == track) | |
64 return *it; | |
65 } | |
66 return NULL; | |
67 } | |
68 | |
69 } // namespace anonymous | |
70 | |
71 namespace content { | |
72 | |
73 RemoteMediaStreamTrackObserver::RemoteMediaStreamTrackObserver( | |
74 webrtc::MediaStreamTrackInterface* webrtc_track, | |
75 const WebKit::WebMediaStreamTrack& webkit_track) | |
76 : state_(webrtc_track->state()), | |
77 webrtc_track_(webrtc_track), | |
78 webkit_track_(webkit_track) { | |
79 webrtc_track->RegisterObserver(this); | |
80 } | |
81 | |
82 RemoteMediaStreamTrackObserver::~RemoteMediaStreamTrackObserver() { | |
83 webrtc_track_->UnregisterObserver(this); | |
84 } | |
85 | |
86 void RemoteMediaStreamTrackObserver::OnChanged() { | |
87 DCHECK(CalledOnValidThread()); | |
88 | |
89 webrtc::MediaStreamTrackInterface::TrackState state = webrtc_track_->state(); | |
90 if (state == state_) | |
91 return; | |
92 | |
93 state_ = state; | |
94 switch (state) { | |
95 case webrtc::MediaStreamTrackInterface::kInitializing: | |
96 // kInitializing is not a WebMediaStreamSource::ReadyState. | |
tommi (sloooow) - chröme
2013/04/18 16:33:31
nit: // Ignore the kInitializing state since there
perkj_chrome
2013/04/19 06:23:21
Done.
| |
97 break; | |
98 case webrtc::MediaStreamTrackInterface::kLive: | |
99 webkit_track_.source().setReadyState( | |
100 WebKit::WebMediaStreamSource::ReadyStateLive); | |
101 break; | |
102 case webrtc::MediaStreamTrackInterface::kEnded: | |
103 webkit_track_.source().setReadyState( | |
104 WebKit::WebMediaStreamSource::ReadyStateEnded); | |
105 break; | |
106 default: | |
107 NOTREACHED(); | |
108 break; | |
109 } | |
110 } | |
111 | |
112 RemoteMediaStreamImpl::RemoteMediaStreamImpl( | |
113 webrtc::MediaStreamInterface* webrtc_stream) | |
114 : webrtc_stream_(webrtc_stream) { | |
115 webrtc_stream_->RegisterObserver(this); | |
116 | |
117 webrtc::AudioTrackVector webrtc_audio_tracks = | |
118 webrtc_stream_->GetAudioTracks(); | |
119 WebKit::WebVector<WebKit::WebMediaStreamTrack> webkit_audio_tracks( | |
120 webrtc_audio_tracks.size()); | |
121 | |
122 // Initialize WebKit audio tracks. | |
123 size_t i = 0; | |
124 for (; i < webrtc_audio_tracks.size(); ++i) { | |
125 webrtc::AudioTrackInterface* audio_track = webrtc_audio_tracks[i]; | |
126 DCHECK(audio_track); | |
127 InitializeWebkitTrack(audio_track, &webkit_audio_tracks[i], | |
128 WebKit::WebMediaStreamSource::TypeAudio); | |
129 audio_track_observers_.push_back( | |
130 new RemoteMediaStreamTrackObserver(audio_track, | |
131 webkit_audio_tracks[i])); | |
132 } | |
133 | |
134 // Initialize WebKit video tracks. | |
135 webrtc::VideoTrackVector webrtc_video_tracks = | |
136 webrtc_stream_->GetVideoTracks(); | |
137 WebKit::WebVector<WebKit::WebMediaStreamTrack> webkit_video_tracks( | |
138 webrtc_video_tracks.size()); | |
139 for (i = 0; i < webrtc_video_tracks.size(); ++i) { | |
140 webrtc::VideoTrackInterface* video_track = webrtc_video_tracks[i]; | |
141 DCHECK(video_track); | |
142 InitializeWebkitTrack(video_track, &webkit_video_tracks[i], | |
143 WebKit::WebMediaStreamSource::TypeVideo); | |
144 video_track_observers_.push_back( | |
145 new RemoteMediaStreamTrackObserver(video_track, | |
146 webkit_video_tracks[i])); | |
147 } | |
148 | |
149 webkit_stream_.initialize(UTF8ToUTF16(webrtc_stream->label()), | |
150 webkit_audio_tracks, webkit_video_tracks); | |
151 webkit_stream_.setExtraData(new MediaStreamExtraData(webrtc_stream, false)); | |
152 } | |
153 | |
154 RemoteMediaStreamImpl::~RemoteMediaStreamImpl() { | |
155 webrtc_stream_->UnregisterObserver(this); | |
156 } | |
157 | |
158 void RemoteMediaStreamImpl::OnChanged() { | |
159 // Find removed audio tracks. | |
160 ScopedVector<RemoteMediaStreamTrackObserver>::iterator audio_it = | |
161 audio_track_observers_.begin(); | |
162 while (audio_it != audio_track_observers_.end()) { | |
163 std::string track_id = (*audio_it)->observered_track()->id(); | |
164 if (webrtc_stream_->FindAudioTrack(track_id) == NULL) { | |
165 webkit_stream_.removeTrack((*audio_it)->webkit_track()); | |
166 audio_it = audio_track_observers_.erase(audio_it); | |
167 } else { | |
168 ++audio_it; | |
169 } | |
170 } | |
171 | |
172 // Find removed video tracks. | |
173 ScopedVector<RemoteMediaStreamTrackObserver>::iterator video_it = | |
174 video_track_observers_.begin(); | |
175 while (video_it != video_track_observers_.end()) { | |
176 std::string track_id = (*video_it)->observered_track()->id(); | |
177 if (webrtc_stream_->FindVideoTrack(track_id) == NULL) { | |
178 webkit_stream_.removeTrack((*video_it)->webkit_track()); | |
179 video_it = video_track_observers_.erase(video_it); | |
180 } else { | |
181 ++video_it; | |
182 } | |
183 } | |
184 | |
185 // Find added audio tracks. | |
186 webrtc::AudioTrackVector webrtc_audio_tracks = | |
187 webrtc_stream_->GetAudioTracks(); | |
188 for (webrtc::AudioTrackVector::iterator it = webrtc_audio_tracks.begin(); | |
189 it != webrtc_audio_tracks.end(); ++it) { | |
190 if (!FindTrackObserver(*it, audio_track_observers_)) { | |
191 WebKit::WebMediaStreamTrack new_track; | |
192 InitializeWebkitTrack(*it, &new_track, | |
193 WebKit::WebMediaStreamSource::TypeAudio); | |
194 audio_track_observers_.push_back( | |
195 new RemoteMediaStreamTrackObserver(*it, new_track)); | |
196 webkit_stream_.addTrack(new_track); | |
197 } | |
198 } | |
199 | |
200 // Find added video tracks. | |
201 webrtc::VideoTrackVector webrtc_video_tracks = | |
202 webrtc_stream_->GetVideoTracks(); | |
203 for (webrtc::VideoTrackVector::iterator it = webrtc_video_tracks.begin(); | |
204 it != webrtc_video_tracks.end(); ++it) { | |
205 if (!FindTrackObserver(*it, video_track_observers_)) { | |
206 WebKit::WebMediaStreamTrack new_track; | |
207 InitializeWebkitTrack(*it, &new_track, | |
208 WebKit::WebMediaStreamSource::TypeVideo); | |
209 video_track_observers_.push_back( | |
210 new RemoteMediaStreamTrackObserver(*it, new_track)); | |
211 webkit_stream_.addTrack(new_track); | |
212 } | |
213 } | |
214 } | |
215 | |
216 } // namespace content | |
OLD | NEW |