src/content/renderer/media/mock_media_stream_dependency_factory.cc

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