content/renderer/media/webrtc/mock_peer_connection_dependency_factory.cc

   1 // Copyright 2014 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/webrtc/mock_peer_connection_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/media/base/videocapturer.h"
  18 #include "third_party/webrtc/base/scoped_ref_ptr.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 rtc::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 rtc::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   void OnFrameCaptured(const scoped_refptr<media::VideoFrame>& frame) override {
 135     ++number_of_capturered_frames_;
 136     width_ = frame->visible_rect().width();
 137     height_ = frame->visible_rect().height();
 138   }
 139
 140   int GetLastFrameWidth() const {
 141     return width_;
 142   }
 143
 144   int GetLastFrameHeight() const {
 145     return height_;
 146   }
 147
 148   int GetFrameNum() const {
 149     return number_of_capturered_frames_;
 150   }
 151
 152  private:
 153   int number_of_capturered_frames_;
 154   int width_;
 155   int height_;
 156 };
 157
 158 MockVideoRenderer::MockVideoRenderer()
 159     : width_(0),
 160       height_(0),
 161       num_(0) {}
 162
 163 MockVideoRenderer::~MockVideoRenderer() {}
 164
 165 bool MockVideoRenderer::SetSize(int width, int height, int reserved) {
 166   width_ = width;
 167   height_ = height;
 168   return true;
 169 }
 170
 171 bool MockVideoRenderer::RenderFrame(const cricket::VideoFrame* frame) {
 172   ++num_;
 173   return true;
 174 }
 175
 176 MockAudioSource::MockAudioSource(
 177     const webrtc::MediaConstraintsInterface* constraints)
 178     : state_(MediaSourceInterface::kLive),
 179       optional_constraints_(constraints->GetOptional()),
 180       mandatory_constraints_(constraints->GetMandatory()) {
 181 }
 182
 183 MockAudioSource::~MockAudioSource() {}
 184
 185 void MockAudioSource::RegisterObserver(webrtc::ObserverInterface* observer) {
 186   DCHECK(observers_.find(observer) == observers_.end());
 187   observers_.insert(observer);
 188 }
 189
 190 void MockAudioSource::UnregisterObserver(webrtc::ObserverInterface* observer) {
 191   DCHECK(observers_.find(observer) != observers_.end());
 192   observers_.erase(observer);
 193 }
 194
 195 webrtc::MediaSourceInterface::SourceState MockAudioSource::state() const {
 196   return state_;
 197 }
 198
 199 MockVideoSource::MockVideoSource()
 200     : state_(MediaSourceInterface::kInitializing) {
 201 }
 202
 203 MockVideoSource::~MockVideoSource() {}
 204
 205 void MockVideoSource::SetVideoCapturer(cricket::VideoCapturer* capturer) {
 206   capturer_.reset(capturer);
 207 }
 208
 209 cricket::VideoCapturer* MockVideoSource::GetVideoCapturer() {
 210   return capturer_.get();
 211 }
 212
 213 void MockVideoSource::AddSink(cricket::VideoRenderer* output) {
 214   NOTIMPLEMENTED();
 215 }
 216
 217 void MockVideoSource::RemoveSink(cricket::VideoRenderer* output) {
 218   NOTIMPLEMENTED();
 219 }
 220
 221 cricket::VideoRenderer* MockVideoSource::FrameInput() {
 222   return &renderer_;
 223 }
 224
 225 void MockVideoSource::RegisterObserver(webrtc::ObserverInterface* observer) {
 226   observers_.push_back(observer);
 227 }
 228
 229 void MockVideoSource::UnregisterObserver(webrtc::ObserverInterface* observer) {
 230   for (std::vector<ObserverInterface*>::iterator it = observers_.begin();
 231        it != observers_.end(); ++it) {
 232     if (*it == observer) {
 233       observers_.erase(it);
 234       break;
 235     }
 236   }
 237 }
 238
 239 void MockVideoSource::FireOnChanged() {
 240   std::vector<ObserverInterface*> observers(observers_);
 241   for (std::vector<ObserverInterface*>::iterator it = observers.begin();
 242        it != observers.end(); ++it) {
 243     (*it)->OnChanged();
 244   }
 245 }
 246
 247 void MockVideoSource::SetLive() {
 248   DCHECK(state_ == MediaSourceInterface::kInitializing ||
 249          state_ == MediaSourceInterface::kLive);
 250   state_ = MediaSourceInterface::kLive;
 251   FireOnChanged();
 252 }
 253
 254 void MockVideoSource::SetEnded() {
 255   DCHECK_NE(MediaSourceInterface::kEnded, state_);
 256   state_ = MediaSourceInterface::kEnded;
 257   FireOnChanged();
 258 }
 259
 260 webrtc::MediaSourceInterface::SourceState MockVideoSource::state() const {
 261   return state_;
 262 }
 263
 264 const cricket::VideoOptions* MockVideoSource::options() const {
 265   NOTIMPLEMENTED();
 266   return NULL;
 267 }
 268
 269 int MockVideoSource::GetLastFrameWidth() const {
 270   DCHECK(capturer_);
 271   return
 272       static_cast<MockRtcVideoCapturer*>(capturer_.get())->GetLastFrameWidth();
 273 }
 274
 275 int MockVideoSource::GetLastFrameHeight() const {
 276   DCHECK(capturer_);
 277   return
 278       static_cast<MockRtcVideoCapturer*>(capturer_.get())->GetLastFrameHeight();
 279 }
 280
 281 int MockVideoSource::GetFrameNum() const {
 282   DCHECK(capturer_);
 283   return static_cast<MockRtcVideoCapturer*>(capturer_.get())->GetFrameNum();
 284 }
 285
 286 MockWebRtcVideoTrack::MockWebRtcVideoTrack(
 287     const std::string& id,
 288     webrtc::VideoSourceInterface* source)
 289     : enabled_(false),
 290       id_(id),
 291       state_(MediaStreamTrackInterface::kLive),
 292       source_(source),
 293       renderer_(NULL) {
 294 }
 295
 296 MockWebRtcVideoTrack::~MockWebRtcVideoTrack() {}
 297
 298 void MockWebRtcVideoTrack::AddRenderer(VideoRendererInterface* renderer) {
 299   DCHECK(!renderer_);
 300   renderer_ = renderer;
 301 }
 302
 303 void MockWebRtcVideoTrack::RemoveRenderer(VideoRendererInterface* renderer) {
 304   DCHECK_EQ(renderer_, renderer);
 305   renderer_ = NULL;
 306 }
 307
 308 std::string MockWebRtcVideoTrack::kind() const {
 309   NOTIMPLEMENTED();
 310   return std::string();
 311 }
 312
 313 std::string MockWebRtcVideoTrack::id() const { return id_; }
 314
 315 bool MockWebRtcVideoTrack::enabled() const { return enabled_; }
 316
 317 MockWebRtcVideoTrack::TrackState MockWebRtcVideoTrack::state() const {
 318   return state_;
 319 }
 320
 321 bool MockWebRtcVideoTrack::set_enabled(bool enable) {
 322   enabled_ = enable;
 323   return true;
 324 }
 325
 326 bool MockWebRtcVideoTrack::set_state(TrackState new_state) {
 327   state_ = new_state;
 328   for (auto& o : observers_)
 329     o->OnChanged();
 330   return true;
 331 }
 332
 333 void MockWebRtcVideoTrack::RegisterObserver(ObserverInterface* observer) {
 334   DCHECK(observers_.find(observer) == observers_.end());
 335   observers_.insert(observer);
 336 }
 337
 338 void MockWebRtcVideoTrack::UnregisterObserver(ObserverInterface* observer) {
 339   DCHECK(observers_.find(observer) != observers_.end());
 340   observers_.erase(observer);
 341 }
 342
 343 VideoSourceInterface* MockWebRtcVideoTrack::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   ~MockSessionDescription() override {}
 355   cricket::SessionDescription* description() override {
 356     NOTIMPLEMENTED();
 357     return NULL;
 358   }
 359   const cricket::SessionDescription* description() const override {
 360     NOTIMPLEMENTED();
 361     return NULL;
 362   }
 363   std::string session_id() const override {
 364     NOTIMPLEMENTED();
 365     return std::string();
 366   }
 367   std::string session_version() const override {
 368     NOTIMPLEMENTED();
 369     return std::string();
 370   }
 371   std::string type() const override { return type_; }
 372   bool AddCandidate(const IceCandidateInterface* candidate) override {
 373     NOTIMPLEMENTED();
 374     return false;
 375   }
 376   size_t number_of_mediasections() const override {
 377     NOTIMPLEMENTED();
 378     return 0;
 379   }
 380   const IceCandidateCollection* candidates(
 381       size_t mediasection_index) const override {
 382     NOTIMPLEMENTED();
 383     return NULL;
 384   }
 385
 386   bool ToString(std::string* out) const override {
 387     *out = sdp_;
 388     return true;
 389   }
 390
 391  private:
 392   std::string type_;
 393   std::string sdp_;
 394 };
 395
 396 class MockIceCandidate : public IceCandidateInterface {
 397  public:
 398   MockIceCandidate(const std::string& sdp_mid,
 399                    int sdp_mline_index,
 400                    const std::string& sdp)
 401       : sdp_mid_(sdp_mid),
 402         sdp_mline_index_(sdp_mline_index),
 403         sdp_(sdp) {
 404     // Assign an valid address to |candidate_| to pass assert in code.
 405     candidate_.set_address(rtc::SocketAddress("127.0.0.1", 5000));
 406   }
 407   ~MockIceCandidate() override {}
 408   std::string sdp_mid() const override { return sdp_mid_; }
 409   int sdp_mline_index() const override { return sdp_mline_index_; }
 410   const cricket::Candidate& candidate() const override { return candidate_; }
 411   bool ToString(std::string* out) const override {
 412     *out = sdp_;
 413     return true;
 414   }
 415
 416  private:
 417   std::string sdp_mid_;
 418   int sdp_mline_index_;
 419   std::string sdp_;
 420   cricket::Candidate candidate_;
 421 };
 422
 423 MockPeerConnectionDependencyFactory::MockPeerConnectionDependencyFactory()
 424     : PeerConnectionDependencyFactory(NULL),
 425       fail_to_create_next_audio_capturer_(false) {
 426 }
 427
 428 MockPeerConnectionDependencyFactory::~MockPeerConnectionDependencyFactory() {}
 429
 430 scoped_refptr<webrtc::PeerConnectionInterface>
 431 MockPeerConnectionDependencyFactory::CreatePeerConnection(
 432     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
 433     const webrtc::MediaConstraintsInterface* constraints,
 434     blink::WebFrame* frame,
 435     webrtc::PeerConnectionObserver* observer) {
 436   return new rtc::RefCountedObject<MockPeerConnectionImpl>(this, observer);
 437 }
 438
 439 scoped_refptr<webrtc::AudioSourceInterface>
 440 MockPeerConnectionDependencyFactory::CreateLocalAudioSource(
 441     const webrtc::MediaConstraintsInterface* constraints) {
 442   last_audio_source_ =
 443       new rtc::RefCountedObject<MockAudioSource>(constraints);
 444   return last_audio_source_;
 445 }
 446
 447 WebRtcVideoCapturerAdapter*
 448 MockPeerConnectionDependencyFactory::CreateVideoCapturer(
 449     bool is_screen_capture) {
 450   return new MockRtcVideoCapturer(is_screen_capture);
 451 }
 452
 453 scoped_refptr<webrtc::VideoSourceInterface>
 454 MockPeerConnectionDependencyFactory::CreateVideoSource(
 455     cricket::VideoCapturer* capturer,
 456     const blink::WebMediaConstraints& constraints) {
 457   last_video_source_ = new rtc::RefCountedObject<MockVideoSource>();
 458   last_video_source_->SetVideoCapturer(capturer);
 459   return last_video_source_;
 460 }
 461
 462 scoped_refptr<WebAudioCapturerSource>
 463 MockPeerConnectionDependencyFactory::CreateWebAudioSource(
 464     blink::WebMediaStreamSource* source) {
 465   return NULL;
 466 }
 467
 468 scoped_refptr<webrtc::MediaStreamInterface>
 469 MockPeerConnectionDependencyFactory::CreateLocalMediaStream(
 470     const std::string& label) {
 471   return new rtc::RefCountedObject<MockMediaStream>(label);
 472 }
 473
 474 scoped_refptr<webrtc::VideoTrackInterface>
 475 MockPeerConnectionDependencyFactory::CreateLocalVideoTrack(
 476     const std::string& id,
 477     webrtc::VideoSourceInterface* source) {
 478   scoped_refptr<webrtc::VideoTrackInterface> track(
 479       new rtc::RefCountedObject<MockWebRtcVideoTrack>(
 480           id, source));
 481   return track;
 482 }
 483
 484 scoped_refptr<webrtc::VideoTrackInterface>
 485 MockPeerConnectionDependencyFactory::CreateLocalVideoTrack(
 486     const std::string& id,
 487     cricket::VideoCapturer* capturer) {
 488   scoped_refptr<MockVideoSource> source =
 489       new rtc::RefCountedObject<MockVideoSource>();
 490   source->SetVideoCapturer(capturer);
 491
 492   return
 493       new rtc::RefCountedObject<MockWebRtcVideoTrack>(id, source.get());
 494 }
 495
 496 SessionDescriptionInterface*
 497 MockPeerConnectionDependencyFactory::CreateSessionDescription(
 498     const std::string& type,
 499     const std::string& sdp,
 500     webrtc::SdpParseError* error) {
 501   return new MockSessionDescription(type, sdp);
 502 }
 503
 504 webrtc::IceCandidateInterface*
 505 MockPeerConnectionDependencyFactory::CreateIceCandidate(
 506     const std::string& sdp_mid,
 507     int sdp_mline_index,
 508     const std::string& sdp) {
 509   return new MockIceCandidate(sdp_mid, sdp_mline_index, sdp);
 510 }
 511
 512 scoped_refptr<WebRtcAudioCapturer>
 513 MockPeerConnectionDependencyFactory::CreateAudioCapturer(
 514     int render_view_id, const StreamDeviceInfo& device_info,
 515     const blink::WebMediaConstraints& constraints,
 516     MediaStreamAudioSource* audio_source) {
 517   if (fail_to_create_next_audio_capturer_) {
 518     fail_to_create_next_audio_capturer_ = false;
 519     return NULL;
 520   }
 521   DCHECK(audio_source);
 522   return WebRtcAudioCapturer::CreateCapturer(-1, device_info,
 523                                              constraints, NULL, audio_source);
 524 }
 525
 526 void MockPeerConnectionDependencyFactory::StartLocalAudioTrack(
 527       WebRtcLocalAudioTrack* audio_track) {
 528   audio_track->Start();
 529 }
 530
 531 }  // namespace content