| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012 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/mock_media_stream_dependency_factory.h" | |
| 6 | |
| 7 #include "base/logging.h" | |
| 8 #include "base/strings/utf_string_conversions.h" | |
| 9 #include "content/renderer/media/mock_peer_connection_impl.h" | |
| 10 #include "content/renderer/media/webaudio_capturer_source.h" | |
| 11 #include "content/renderer/media/webrtc/webrtc_local_audio_track_adapter.h" | |
| 12 #include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h" | |
| 13 #include "content/renderer/media/webrtc_audio_capturer.h" | |
| 14 #include "content/renderer/media/webrtc_local_audio_track.h" | |
| 15 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h" | |
| 16 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h" | |
| 17 #include "third_party/libjingle/source/talk/base/scoped_ref_ptr.h" | |
| 18 #include "third_party/libjingle/source/talk/media/base/videocapturer.h" | |
| 19 | |
| 20 using webrtc::AudioSourceInterface; | |
| 21 using webrtc::AudioTrackInterface; | |
| 22 using webrtc::AudioTrackVector; | |
| 23 using webrtc::IceCandidateCollection; | |
| 24 using webrtc::IceCandidateInterface; | |
| 25 using webrtc::MediaStreamInterface; | |
| 26 using webrtc::ObserverInterface; | |
| 27 using webrtc::SessionDescriptionInterface; | |
| 28 using webrtc::VideoRendererInterface; | |
| 29 using webrtc::VideoSourceInterface; | |
| 30 using webrtc::VideoTrackInterface; | |
| 31 using webrtc::VideoTrackVector; | |
| 32 | |
| 33 namespace content { | |
| 34 | |
| 35 template <class V> | |
| 36 static typename V::iterator FindTrack(V* vector, | |
| 37 const std::string& track_id) { | |
| 38 typename V::iterator it = vector->begin(); | |
| 39 for (; it != vector->end(); ++it) { | |
| 40 if ((*it)->id() == track_id) { | |
| 41 break; | |
| 42 } | |
| 43 } | |
| 44 return it; | |
| 45 }; | |
| 46 | |
| 47 MockMediaStream::MockMediaStream(const std::string& label) : label_(label) {} | |
| 48 | |
| 49 bool MockMediaStream::AddTrack(AudioTrackInterface* track) { | |
| 50 audio_track_vector_.push_back(track); | |
| 51 NotifyObservers(); | |
| 52 return true; | |
| 53 } | |
| 54 | |
| 55 bool MockMediaStream::AddTrack(VideoTrackInterface* track) { | |
| 56 video_track_vector_.push_back(track); | |
| 57 NotifyObservers(); | |
| 58 return true; | |
| 59 } | |
| 60 | |
| 61 bool MockMediaStream::RemoveTrack(AudioTrackInterface* track) { | |
| 62 AudioTrackVector::iterator it = FindTrack(&audio_track_vector_, | |
| 63 track->id()); | |
| 64 if (it == audio_track_vector_.end()) | |
| 65 return false; | |
| 66 audio_track_vector_.erase(it); | |
| 67 NotifyObservers(); | |
| 68 return true; | |
| 69 } | |
| 70 | |
| 71 bool MockMediaStream::RemoveTrack(VideoTrackInterface* track) { | |
| 72 VideoTrackVector::iterator it = FindTrack(&video_track_vector_, | |
| 73 track->id()); | |
| 74 if (it == video_track_vector_.end()) | |
| 75 return false; | |
| 76 video_track_vector_.erase(it); | |
| 77 NotifyObservers(); | |
| 78 return true; | |
| 79 } | |
| 80 | |
| 81 std::string MockMediaStream::label() const { | |
| 82 return label_; | |
| 83 } | |
| 84 | |
| 85 AudioTrackVector MockMediaStream::GetAudioTracks() { | |
| 86 return audio_track_vector_; | |
| 87 } | |
| 88 | |
| 89 VideoTrackVector MockMediaStream::GetVideoTracks() { | |
| 90 return video_track_vector_; | |
| 91 } | |
| 92 | |
| 93 talk_base::scoped_refptr<AudioTrackInterface> MockMediaStream::FindAudioTrack( | |
| 94 const std::string& track_id) { | |
| 95 AudioTrackVector::iterator it = FindTrack(&audio_track_vector_, track_id); | |
| 96 return it == audio_track_vector_.end() ? NULL : *it; | |
| 97 } | |
| 98 | |
| 99 talk_base::scoped_refptr<VideoTrackInterface> MockMediaStream::FindVideoTrack( | |
| 100 const std::string& track_id) { | |
| 101 VideoTrackVector::iterator it = FindTrack(&video_track_vector_, track_id); | |
| 102 return it == video_track_vector_.end() ? NULL : *it; | |
| 103 } | |
| 104 | |
| 105 void MockMediaStream::RegisterObserver(ObserverInterface* observer) { | |
| 106 DCHECK(observers_.find(observer) == observers_.end()); | |
| 107 observers_.insert(observer); | |
| 108 } | |
| 109 | |
| 110 void MockMediaStream::UnregisterObserver(ObserverInterface* observer) { | |
| 111 ObserverSet::iterator it = observers_.find(observer); | |
| 112 DCHECK(it != observers_.end()); | |
| 113 observers_.erase(it); | |
| 114 } | |
| 115 | |
| 116 void MockMediaStream::NotifyObservers() { | |
| 117 for (ObserverSet::iterator it = observers_.begin(); it != observers_.end(); | |
| 118 ++it) { | |
| 119 (*it)->OnChanged(); | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 MockMediaStream::~MockMediaStream() {} | |
| 124 | |
| 125 class MockRtcVideoCapturer : public WebRtcVideoCapturerAdapter { | |
| 126 public: | |
| 127 explicit MockRtcVideoCapturer(bool is_screencast) | |
| 128 : WebRtcVideoCapturerAdapter(is_screencast), | |
| 129 number_of_capturered_frames_(0), | |
| 130 width_(0), | |
| 131 height_(0) { | |
| 132 } | |
| 133 | |
| 134 virtual void OnFrameCaptured( | |
| 135 const scoped_refptr<media::VideoFrame>& frame) OVERRIDE { | |
| 136 ++number_of_capturered_frames_; | |
| 137 width_ = frame->visible_rect().width(); | |
| 138 height_ = frame->visible_rect().height(); | |
| 139 } | |
| 140 | |
| 141 int GetLastFrameWidth() const { | |
| 142 return width_; | |
| 143 } | |
| 144 | |
| 145 int GetLastFrameHeight() const { | |
| 146 return height_; | |
| 147 } | |
| 148 | |
| 149 int GetFrameNum() const { | |
| 150 return number_of_capturered_frames_; | |
| 151 } | |
| 152 | |
| 153 private: | |
| 154 int number_of_capturered_frames_; | |
| 155 int width_; | |
| 156 int height_; | |
| 157 }; | |
| 158 | |
| 159 MockVideoRenderer::MockVideoRenderer() | |
| 160 : width_(0), | |
| 161 height_(0), | |
| 162 num_(0) {} | |
| 163 | |
| 164 MockVideoRenderer::~MockVideoRenderer() {} | |
| 165 | |
| 166 bool MockVideoRenderer::SetSize(int width, int height, int reserved) { | |
| 167 width_ = width; | |
| 168 height_ = height; | |
| 169 return true; | |
| 170 } | |
| 171 | |
| 172 bool MockVideoRenderer::RenderFrame(const cricket::VideoFrame* frame) { | |
| 173 ++num_; | |
| 174 return true; | |
| 175 } | |
| 176 | |
| 177 MockAudioSource::MockAudioSource( | |
| 178 const webrtc::MediaConstraintsInterface* constraints) | |
| 179 : observer_(NULL), | |
| 180 state_(MediaSourceInterface::kLive), | |
| 181 optional_constraints_(constraints->GetOptional()), | |
| 182 mandatory_constraints_(constraints->GetMandatory()) { | |
| 183 } | |
| 184 | |
| 185 MockAudioSource::~MockAudioSource() {} | |
| 186 | |
| 187 void MockAudioSource::RegisterObserver(webrtc::ObserverInterface* observer) { | |
| 188 observer_ = observer; | |
| 189 } | |
| 190 | |
| 191 void MockAudioSource::UnregisterObserver(webrtc::ObserverInterface* observer) { | |
| 192 DCHECK(observer_ == observer); | |
| 193 observer_ = NULL; | |
| 194 } | |
| 195 | |
| 196 webrtc::MediaSourceInterface::SourceState MockAudioSource::state() const { | |
| 197 return state_; | |
| 198 } | |
| 199 | |
| 200 MockVideoSource::MockVideoSource() | |
| 201 : state_(MediaSourceInterface::kInitializing) { | |
| 202 } | |
| 203 | |
| 204 MockVideoSource::~MockVideoSource() {} | |
| 205 | |
| 206 void MockVideoSource::SetVideoCapturer(cricket::VideoCapturer* capturer) { | |
| 207 capturer_.reset(capturer); | |
| 208 } | |
| 209 | |
| 210 cricket::VideoCapturer* MockVideoSource::GetVideoCapturer() { | |
| 211 return capturer_.get(); | |
| 212 } | |
| 213 | |
| 214 void MockVideoSource::AddSink(cricket::VideoRenderer* output) { | |
| 215 NOTIMPLEMENTED(); | |
| 216 } | |
| 217 | |
| 218 void MockVideoSource::RemoveSink(cricket::VideoRenderer* output) { | |
| 219 NOTIMPLEMENTED(); | |
| 220 } | |
| 221 | |
| 222 cricket::VideoRenderer* MockVideoSource::FrameInput() { | |
| 223 return &renderer_; | |
| 224 } | |
| 225 | |
| 226 void MockVideoSource::RegisterObserver(webrtc::ObserverInterface* observer) { | |
| 227 observers_.push_back(observer); | |
| 228 } | |
| 229 | |
| 230 void MockVideoSource::UnregisterObserver(webrtc::ObserverInterface* observer) { | |
| 231 for (std::vector<ObserverInterface*>::iterator it = observers_.begin(); | |
| 232 it != observers_.end(); ++it) { | |
| 233 if (*it == observer) { | |
| 234 observers_.erase(it); | |
| 235 break; | |
| 236 } | |
| 237 } | |
| 238 } | |
| 239 | |
| 240 void MockVideoSource::FireOnChanged() { | |
| 241 std::vector<ObserverInterface*> observers(observers_); | |
| 242 for (std::vector<ObserverInterface*>::iterator it = observers.begin(); | |
| 243 it != observers.end(); ++it) { | |
| 244 (*it)->OnChanged(); | |
| 245 } | |
| 246 } | |
| 247 | |
| 248 void MockVideoSource::SetLive() { | |
| 249 DCHECK(state_ == MediaSourceInterface::kInitializing || | |
| 250 state_ == MediaSourceInterface::kLive); | |
| 251 state_ = MediaSourceInterface::kLive; | |
| 252 FireOnChanged(); | |
| 253 } | |
| 254 | |
| 255 void MockVideoSource::SetEnded() { | |
| 256 DCHECK_NE(MediaSourceInterface::kEnded, state_); | |
| 257 state_ = MediaSourceInterface::kEnded; | |
| 258 FireOnChanged(); | |
| 259 } | |
| 260 | |
| 261 webrtc::MediaSourceInterface::SourceState MockVideoSource::state() const { | |
| 262 return state_; | |
| 263 } | |
| 264 | |
| 265 const cricket::VideoOptions* MockVideoSource::options() const { | |
| 266 NOTIMPLEMENTED(); | |
| 267 return NULL; | |
| 268 } | |
| 269 | |
| 270 int MockVideoSource::GetLastFrameWidth() const { | |
| 271 DCHECK(capturer_); | |
| 272 return | |
| 273 static_cast<MockRtcVideoCapturer*>(capturer_.get())->GetLastFrameWidth(); | |
| 274 } | |
| 275 | |
| 276 int MockVideoSource::GetLastFrameHeight() const { | |
| 277 DCHECK(capturer_); | |
| 278 return | |
| 279 static_cast<MockRtcVideoCapturer*>(capturer_.get())->GetLastFrameHeight(); | |
| 280 } | |
| 281 | |
| 282 int MockVideoSource::GetFrameNum() const { | |
| 283 DCHECK(capturer_); | |
| 284 return static_cast<MockRtcVideoCapturer*>(capturer_.get())->GetFrameNum(); | |
| 285 } | |
| 286 | |
| 287 MockWebRtcVideoTrack::MockWebRtcVideoTrack( | |
| 288 const std::string& id, | |
| 289 webrtc::VideoSourceInterface* source) | |
| 290 : enabled_(false), | |
| 291 id_(id), | |
| 292 state_(MediaStreamTrackInterface::kLive), | |
| 293 source_(source), | |
| 294 observer_(NULL), | |
| 295 renderer_(NULL) { | |
| 296 } | |
| 297 | |
| 298 MockWebRtcVideoTrack::~MockWebRtcVideoTrack() {} | |
| 299 | |
| 300 void MockWebRtcVideoTrack::AddRenderer(VideoRendererInterface* renderer) { | |
| 301 DCHECK(!renderer_); | |
| 302 renderer_ = renderer; | |
| 303 } | |
| 304 | |
| 305 void MockWebRtcVideoTrack::RemoveRenderer(VideoRendererInterface* renderer) { | |
| 306 DCHECK_EQ(renderer_, renderer); | |
| 307 renderer_ = NULL; | |
| 308 } | |
| 309 | |
| 310 std::string MockWebRtcVideoTrack::kind() const { | |
| 311 NOTIMPLEMENTED(); | |
| 312 return std::string(); | |
| 313 } | |
| 314 | |
| 315 std::string MockWebRtcVideoTrack::id() const { return id_; } | |
| 316 | |
| 317 bool MockWebRtcVideoTrack::enabled() const { return enabled_; } | |
| 318 | |
| 319 MockWebRtcVideoTrack::TrackState MockWebRtcVideoTrack::state() const { | |
| 320 return state_; | |
| 321 } | |
| 322 | |
| 323 bool MockWebRtcVideoTrack::set_enabled(bool enable) { | |
| 324 enabled_ = enable; | |
| 325 return true; | |
| 326 } | |
| 327 | |
| 328 bool MockWebRtcVideoTrack::set_state(TrackState new_state) { | |
| 329 state_ = new_state; | |
| 330 if (observer_) | |
| 331 observer_->OnChanged(); | |
| 332 return true; | |
| 333 } | |
| 334 | |
| 335 void MockWebRtcVideoTrack::RegisterObserver(ObserverInterface* observer) { | |
| 336 observer_ = observer; | |
| 337 } | |
| 338 | |
| 339 void MockWebRtcVideoTrack::UnregisterObserver(ObserverInterface* observer) { | |
| 340 DCHECK(observer_ == observer); | |
| 341 observer_ = NULL; | |
| 342 } | |
| 343 | |
| 344 VideoSourceInterface* MockWebRtcVideoTrack::GetSource() const { | |
| 345 return source_.get(); | |
| 346 } | |
| 347 | |
| 348 class MockSessionDescription : public SessionDescriptionInterface { | |
| 349 public: | |
| 350 MockSessionDescription(const std::string& type, | |
| 351 const std::string& sdp) | |
| 352 : type_(type), | |
| 353 sdp_(sdp) { | |
| 354 } | |
| 355 virtual ~MockSessionDescription() {} | |
| 356 virtual cricket::SessionDescription* description() OVERRIDE { | |
| 357 NOTIMPLEMENTED(); | |
| 358 return NULL; | |
| 359 } | |
| 360 virtual const cricket::SessionDescription* description() const OVERRIDE { | |
| 361 NOTIMPLEMENTED(); | |
| 362 return NULL; | |
| 363 } | |
| 364 virtual std::string session_id() const OVERRIDE { | |
| 365 NOTIMPLEMENTED(); | |
| 366 return std::string(); | |
| 367 } | |
| 368 virtual std::string session_version() const OVERRIDE { | |
| 369 NOTIMPLEMENTED(); | |
| 370 return std::string(); | |
| 371 } | |
| 372 virtual std::string type() const OVERRIDE { | |
| 373 return type_; | |
| 374 } | |
| 375 virtual bool AddCandidate(const IceCandidateInterface* candidate) OVERRIDE { | |
| 376 NOTIMPLEMENTED(); | |
| 377 return false; | |
| 378 } | |
| 379 virtual size_t number_of_mediasections() const OVERRIDE { | |
| 380 NOTIMPLEMENTED(); | |
| 381 return 0; | |
| 382 } | |
| 383 virtual const IceCandidateCollection* candidates( | |
| 384 size_t mediasection_index) const OVERRIDE { | |
| 385 NOTIMPLEMENTED(); | |
| 386 return NULL; | |
| 387 } | |
| 388 | |
| 389 virtual bool ToString(std::string* out) const OVERRIDE { | |
| 390 *out = sdp_; | |
| 391 return true; | |
| 392 } | |
| 393 | |
| 394 private: | |
| 395 std::string type_; | |
| 396 std::string sdp_; | |
| 397 }; | |
| 398 | |
| 399 class MockIceCandidate : public IceCandidateInterface { | |
| 400 public: | |
| 401 MockIceCandidate(const std::string& sdp_mid, | |
| 402 int sdp_mline_index, | |
| 403 const std::string& sdp) | |
| 404 : sdp_mid_(sdp_mid), | |
| 405 sdp_mline_index_(sdp_mline_index), | |
| 406 sdp_(sdp) { | |
| 407 } | |
| 408 virtual ~MockIceCandidate() {} | |
| 409 virtual std::string sdp_mid() const OVERRIDE { | |
| 410 return sdp_mid_; | |
| 411 } | |
| 412 virtual int sdp_mline_index() const OVERRIDE { | |
| 413 return sdp_mline_index_; | |
| 414 } | |
| 415 virtual const cricket::Candidate& candidate() const OVERRIDE { | |
| 416 // This function should never be called. It will intentionally crash. The | |
| 417 // base class forces us to return a reference. | |
| 418 NOTREACHED(); | |
| 419 cricket::Candidate* candidate = NULL; | |
| 420 return *candidate; | |
| 421 } | |
| 422 virtual bool ToString(std::string* out) const OVERRIDE { | |
| 423 *out = sdp_; | |
| 424 return true; | |
| 425 } | |
| 426 | |
| 427 private: | |
| 428 std::string sdp_mid_; | |
| 429 int sdp_mline_index_; | |
| 430 std::string sdp_; | |
| 431 }; | |
| 432 | |
| 433 MockMediaStreamDependencyFactory::MockMediaStreamDependencyFactory() | |
| 434 : MediaStreamDependencyFactory(NULL), | |
| 435 fail_to_create_next_audio_capturer_(false) { | |
| 436 } | |
| 437 | |
| 438 MockMediaStreamDependencyFactory::~MockMediaStreamDependencyFactory() {} | |
| 439 | |
| 440 scoped_refptr<webrtc::PeerConnectionInterface> | |
| 441 MockMediaStreamDependencyFactory::CreatePeerConnection( | |
| 442 const webrtc::PeerConnectionInterface::IceServers& ice_servers, | |
| 443 const webrtc::MediaConstraintsInterface* constraints, | |
| 444 blink::WebFrame* frame, | |
| 445 webrtc::PeerConnectionObserver* observer) { | |
| 446 return new talk_base::RefCountedObject<MockPeerConnectionImpl>(this); | |
| 447 } | |
| 448 | |
| 449 scoped_refptr<webrtc::AudioSourceInterface> | |
| 450 MockMediaStreamDependencyFactory::CreateLocalAudioSource( | |
| 451 const webrtc::MediaConstraintsInterface* constraints) { | |
| 452 last_audio_source_ = | |
| 453 new talk_base::RefCountedObject<MockAudioSource>(constraints); | |
| 454 return last_audio_source_; | |
| 455 } | |
| 456 | |
| 457 WebRtcVideoCapturerAdapter* | |
| 458 MockMediaStreamDependencyFactory::CreateVideoCapturer( | |
| 459 bool is_screen_capture) { | |
| 460 return new MockRtcVideoCapturer(is_screen_capture); | |
| 461 } | |
| 462 | |
| 463 scoped_refptr<webrtc::VideoSourceInterface> | |
| 464 MockMediaStreamDependencyFactory::CreateVideoSource( | |
| 465 cricket::VideoCapturer* capturer, | |
| 466 const blink::WebMediaConstraints& constraints) { | |
| 467 last_video_source_ = new talk_base::RefCountedObject<MockVideoSource>(); | |
| 468 last_video_source_->SetVideoCapturer(capturer); | |
| 469 return last_video_source_; | |
| 470 } | |
| 471 | |
| 472 scoped_refptr<WebAudioCapturerSource> | |
| 473 MockMediaStreamDependencyFactory::CreateWebAudioSource( | |
| 474 blink::WebMediaStreamSource* source) { | |
| 475 return NULL; | |
| 476 } | |
| 477 | |
| 478 scoped_refptr<webrtc::MediaStreamInterface> | |
| 479 MockMediaStreamDependencyFactory::CreateLocalMediaStream( | |
| 480 const std::string& label) { | |
| 481 return new talk_base::RefCountedObject<MockMediaStream>(label); | |
| 482 } | |
| 483 | |
| 484 scoped_refptr<webrtc::VideoTrackInterface> | |
| 485 MockMediaStreamDependencyFactory::CreateLocalVideoTrack( | |
| 486 const std::string& id, | |
| 487 webrtc::VideoSourceInterface* source) { | |
| 488 scoped_refptr<webrtc::VideoTrackInterface> track( | |
| 489 new talk_base::RefCountedObject<MockWebRtcVideoTrack>( | |
| 490 id, source)); | |
| 491 return track; | |
| 492 } | |
| 493 | |
| 494 scoped_refptr<webrtc::VideoTrackInterface> | |
| 495 MockMediaStreamDependencyFactory::CreateLocalVideoTrack( | |
| 496 const std::string& id, | |
| 497 cricket::VideoCapturer* capturer) { | |
| 498 scoped_refptr<MockVideoSource> source = | |
| 499 new talk_base::RefCountedObject<MockVideoSource>(); | |
| 500 source->SetVideoCapturer(capturer); | |
| 501 | |
| 502 return | |
| 503 new talk_base::RefCountedObject<MockWebRtcVideoTrack>(id, source.get()); | |
| 504 } | |
| 505 | |
| 506 SessionDescriptionInterface* | |
| 507 MockMediaStreamDependencyFactory::CreateSessionDescription( | |
| 508 const std::string& type, | |
| 509 const std::string& sdp, | |
| 510 webrtc::SdpParseError* error) { | |
| 511 return new MockSessionDescription(type, sdp); | |
| 512 } | |
| 513 | |
| 514 webrtc::IceCandidateInterface* | |
| 515 MockMediaStreamDependencyFactory::CreateIceCandidate( | |
| 516 const std::string& sdp_mid, | |
| 517 int sdp_mline_index, | |
| 518 const std::string& sdp) { | |
| 519 return new MockIceCandidate(sdp_mid, sdp_mline_index, sdp); | |
| 520 } | |
| 521 | |
| 522 scoped_refptr<WebRtcAudioCapturer> | |
| 523 MockMediaStreamDependencyFactory::CreateAudioCapturer( | |
| 524 int render_view_id, const StreamDeviceInfo& device_info, | |
| 525 const blink::WebMediaConstraints& constraints, | |
| 526 MediaStreamAudioSource* audio_source) { | |
| 527 if (fail_to_create_next_audio_capturer_) { | |
| 528 fail_to_create_next_audio_capturer_ = false; | |
| 529 return NULL; | |
| 530 } | |
| 531 DCHECK(audio_source); | |
| 532 return WebRtcAudioCapturer::CreateCapturer(-1, device_info, | |
| 533 constraints, NULL, audio_source); | |
| 534 } | |
| 535 | |
| 536 void MockMediaStreamDependencyFactory::StartLocalAudioTrack( | |
| 537 WebRtcLocalAudioTrack* audio_track) { | |
| 538 audio_track->Start(); | |
| 539 } | |
| 540 | |
| 541 } // namespace content | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 272043003:
Renamed MediaStreamDependencyFactory to PeerConnectionDependencyFactory. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src