src/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   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     // Assign an valid address to |candidate_| to pass assert in code.
 408     candidate_.set_address(rtc::SocketAddress("127.0.0.1", 5000));
 409   }
 410   virtual ~MockIceCandidate() {}
 411   virtual std::string sdp_mid() const OVERRIDE {
 412     return sdp_mid_;
 413   }
 414   virtual int sdp_mline_index() const OVERRIDE {
 415     return sdp_mline_index_;
 416   }
 417   virtual const cricket::Candidate& candidate() const OVERRIDE {
 418     return candidate_;
 419   }
 420   virtual bool ToString(std::string* out) const OVERRIDE {
 421     *out = sdp_;
 422     return true;
 423   }
 424
 425  private:
 426   std::string sdp_mid_;
 427   int sdp_mline_index_;
 428   std::string sdp_;
 429   cricket::Candidate candidate_;
 430 };
 431
 432 MockPeerConnectionDependencyFactory::MockPeerConnectionDependencyFactory()
 433     : PeerConnectionDependencyFactory(NULL),
 434       fail_to_create_next_audio_capturer_(false) {
 435 }
 436
 437 MockPeerConnectionDependencyFactory::~MockPeerConnectionDependencyFactory() {}
 438
 439 scoped_refptr<webrtc::PeerConnectionInterface>
 440 MockPeerConnectionDependencyFactory::CreatePeerConnection(
 441     const webrtc::PeerConnectionInterface::RTCConfiguration& config,
 442     const webrtc::MediaConstraintsInterface* constraints,
 443     blink::WebFrame* frame,
 444     webrtc::PeerConnectionObserver* observer) {
 445   return new rtc::RefCountedObject<MockPeerConnectionImpl>(this);
 446 }
 447
 448 scoped_refptr<webrtc::AudioSourceInterface>
 449 MockPeerConnectionDependencyFactory::CreateLocalAudioSource(
 450     const webrtc::MediaConstraintsInterface* constraints) {
 451   last_audio_source_ =
 452       new rtc::RefCountedObject<MockAudioSource>(constraints);
 453   return last_audio_source_;
 454 }
 455
 456 WebRtcVideoCapturerAdapter*
 457 MockPeerConnectionDependencyFactory::CreateVideoCapturer(
 458     bool is_screen_capture) {
 459   return new MockRtcVideoCapturer(is_screen_capture);
 460 }
 461
 462 scoped_refptr<webrtc::VideoSourceInterface>
 463 MockPeerConnectionDependencyFactory::CreateVideoSource(
 464     cricket::VideoCapturer* capturer,
 465     const blink::WebMediaConstraints& constraints) {
 466   last_video_source_ = new rtc::RefCountedObject<MockVideoSource>();
 467   last_video_source_->SetVideoCapturer(capturer);
 468   return last_video_source_;
 469 }
 470
 471 scoped_refptr<WebAudioCapturerSource>
 472 MockPeerConnectionDependencyFactory::CreateWebAudioSource(
 473     blink::WebMediaStreamSource* source) {
 474   return NULL;
 475 }
 476
 477 scoped_refptr<webrtc::MediaStreamInterface>
 478 MockPeerConnectionDependencyFactory::CreateLocalMediaStream(
 479     const std::string& label) {
 480   return new rtc::RefCountedObject<MockMediaStream>(label);
 481 }
 482
 483 scoped_refptr<webrtc::VideoTrackInterface>
 484 MockPeerConnectionDependencyFactory::CreateLocalVideoTrack(
 485     const std::string& id,
 486     webrtc::VideoSourceInterface* source) {
 487   scoped_refptr<webrtc::VideoTrackInterface> track(
 488       new rtc::RefCountedObject<MockWebRtcVideoTrack>(
 489           id, source));
 490   return track;
 491 }
 492
 493 scoped_refptr<webrtc::VideoTrackInterface>
 494 MockPeerConnectionDependencyFactory::CreateLocalVideoTrack(
 495     const std::string& id,
 496     cricket::VideoCapturer* capturer) {
 497   scoped_refptr<MockVideoSource> source =
 498       new rtc::RefCountedObject<MockVideoSource>();
 499   source->SetVideoCapturer(capturer);
 500
 501   return
 502       new rtc::RefCountedObject<MockWebRtcVideoTrack>(id, source.get());
 503 }
 504
 505 SessionDescriptionInterface*
 506 MockPeerConnectionDependencyFactory::CreateSessionDescription(
 507     const std::string& type,
 508     const std::string& sdp,
 509     webrtc::SdpParseError* error) {
 510   return new MockSessionDescription(type, sdp);
 511 }
 512
 513 webrtc::IceCandidateInterface*
 514 MockPeerConnectionDependencyFactory::CreateIceCandidate(
 515     const std::string& sdp_mid,
 516     int sdp_mline_index,
 517     const std::string& sdp) {
 518   return new MockIceCandidate(sdp_mid, sdp_mline_index, sdp);
 519 }
 520
 521 scoped_refptr<WebRtcAudioCapturer>
 522 MockPeerConnectionDependencyFactory::CreateAudioCapturer(
 523     int render_view_id, const StreamDeviceInfo& device_info,
 524     const blink::WebMediaConstraints& constraints,
 525     MediaStreamAudioSource* audio_source) {
 526   if (fail_to_create_next_audio_capturer_) {
 527     fail_to_create_next_audio_capturer_ = false;
 528     return NULL;
 529   }
 530   DCHECK(audio_source);
 531   return WebRtcAudioCapturer::CreateCapturer(-1, device_info,
 532                                              constraints, NULL, audio_source);
 533 }
 534
 535 void MockPeerConnectionDependencyFactory::StartLocalAudioTrack(
 536       WebRtcLocalAudioTrack* audio_track) {
 537   audio_track->Start();
 538 }
 539
 540 }  // namespace content