content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h

   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 #ifndef CONTENT_RENDERER_MEDIA_WEBRTC_MOCK_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
   6 #define CONTENT_RENDERER_MEDIA_WEBRTC_MOCK_PEER_CONNECTION_DEPENDENCY_FACTORY_H_
   7
   8 #include <set>
   9 #include <string>
  10 #include <vector>
  11
  12 #include "base/compiler_specific.h"
  13 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
  14 #include "third_party/libjingle/source/talk/app/webrtc/mediaconstraintsinterface.h"
  15 #include "third_party/libjingle/source/talk/media/base/videorenderer.h"
  16
  17 namespace content {
  18
  19 class WebAudioCapturerSource;
  20
  21 class MockVideoRenderer : public cricket::VideoRenderer {
  22  public:
  23   MockVideoRenderer();
  24   ~MockVideoRenderer() override;
  25   bool SetSize(int width, int height, int reserved) override;
  26   bool RenderFrame(const cricket::VideoFrame* frame) override;
  27
  28   int width() const { return width_; }
  29   int height() const { return height_; }
  30   int num() const { return num_; }
  31
  32  private:
  33   int width_;
  34   int height_;
  35   int num_;
  36 };
  37
  38 class MockVideoSource : public webrtc::VideoSourceInterface {
  39  public:
  40   MockVideoSource();
  41
  42   void RegisterObserver(webrtc::ObserverInterface* observer) override;
  43   void UnregisterObserver(webrtc::ObserverInterface* observer) override;
  44   MediaSourceInterface::SourceState state() const override;
  45   cricket::VideoCapturer* GetVideoCapturer() override;
  46   void AddSink(cricket::VideoRenderer* output) override;
  47   void RemoveSink(cricket::VideoRenderer* output) override;
  48   cricket::VideoRenderer* FrameInput() override;
  49   const cricket::VideoOptions* options() const override;
  50
  51   // Changes the state of the source to live and notifies the observer.
  52   void SetLive();
  53   // Changes the state of the source to ended and notifies the observer.
  54   void SetEnded();
  55   // Set the video capturer.
  56   void SetVideoCapturer(cricket::VideoCapturer* capturer);
  57
  58   // Test helpers.
  59   int GetLastFrameWidth() const;
  60   int GetLastFrameHeight() const;
  61   int GetFrameNum() const;
  62
  63  protected:
  64   ~MockVideoSource() override;
  65
  66  private:
  67   void FireOnChanged();
  68
  69   std::vector<webrtc::ObserverInterface*> observers_;
  70   MediaSourceInterface::SourceState state_;
  71   scoped_ptr<cricket::VideoCapturer> capturer_;
  72   MockVideoRenderer renderer_;
  73 };
  74
  75 class MockAudioSource : public webrtc::AudioSourceInterface {
  76  public:
  77   explicit MockAudioSource(
  78       const webrtc::MediaConstraintsInterface* constraints);
  79
  80   void RegisterObserver(webrtc::ObserverInterface* observer) override;
  81   void UnregisterObserver(webrtc::ObserverInterface* observer) override;
  82   MediaSourceInterface::SourceState state() const override;
  83
  84   // Changes the state of the source to live and notifies the observer.
  85   void SetLive();
  86   // Changes the state of the source to ended and notifies the observer.
  87   void SetEnded();
  88
  89   const webrtc::MediaConstraintsInterface::Constraints& optional_constraints() {
  90     return optional_constraints_;
  91   }
  92
  93   const webrtc::MediaConstraintsInterface::Constraints&
  94   mandatory_constraints() {
  95     return mandatory_constraints_;
  96   }
  97
  98  protected:
  99   ~MockAudioSource() override;
 100
 101  private:
 102   webrtc::ObserverInterface* observer_;
 103   MediaSourceInterface::SourceState state_;
 104   webrtc::MediaConstraintsInterface::Constraints optional_constraints_;
 105   webrtc::MediaConstraintsInterface::Constraints mandatory_constraints_;
 106 };
 107
 108 class MockWebRtcVideoTrack : public webrtc::VideoTrackInterface {
 109  public:
 110   MockWebRtcVideoTrack(const std::string& id,
 111                       webrtc::VideoSourceInterface* source);
 112   void AddRenderer(webrtc::VideoRendererInterface* renderer) override;
 113   void RemoveRenderer(webrtc::VideoRendererInterface* renderer) override;
 114   std::string kind() const override;
 115   std::string id() const override;
 116   bool enabled() const override;
 117   TrackState state() const override;
 118   bool set_enabled(bool enable) override;
 119   bool set_state(TrackState new_state) override;
 120   void RegisterObserver(webrtc::ObserverInterface* observer) override;
 121   void UnregisterObserver(webrtc::ObserverInterface* observer) override;
 122   webrtc::VideoSourceInterface* GetSource() const override;
 123
 124  protected:
 125   ~MockWebRtcVideoTrack() override;
 126
 127  private:
 128   bool enabled_;
 129   std::string id_;
 130   TrackState state_;
 131   scoped_refptr<webrtc::VideoSourceInterface> source_;
 132   webrtc::ObserverInterface* observer_;
 133   webrtc::VideoRendererInterface* renderer_;
 134 };
 135
 136 class MockMediaStream : public webrtc::MediaStreamInterface {
 137  public:
 138   explicit MockMediaStream(const std::string& label);
 139
 140   bool AddTrack(webrtc::AudioTrackInterface* track) override;
 141   bool AddTrack(webrtc::VideoTrackInterface* track) override;
 142   bool RemoveTrack(webrtc::AudioTrackInterface* track) override;
 143   bool RemoveTrack(webrtc::VideoTrackInterface* track) override;
 144   std::string label() const override;
 145   webrtc::AudioTrackVector GetAudioTracks() override;
 146   webrtc::VideoTrackVector GetVideoTracks() override;
 147   rtc::scoped_refptr<webrtc::AudioTrackInterface> FindAudioTrack(
 148       const std::string& track_id) override;
 149   rtc::scoped_refptr<webrtc::VideoTrackInterface> FindVideoTrack(
 150       const std::string& track_id) override;
 151   void RegisterObserver(webrtc::ObserverInterface* observer) override;
 152   void UnregisterObserver(webrtc::ObserverInterface* observer) override;
 153
 154  protected:
 155   ~MockMediaStream() override;
 156
 157  private:
 158   void NotifyObservers();
 159
 160   std::string label_;
 161   webrtc::AudioTrackVector audio_track_vector_;
 162   webrtc::VideoTrackVector video_track_vector_;
 163
 164   typedef std::set<webrtc::ObserverInterface*> ObserverSet;
 165   ObserverSet observers_;
 166 };
 167
 168 // A mock factory for creating different objects for
 169 // RTC PeerConnections.
 170 class MockPeerConnectionDependencyFactory
 171      : public PeerConnectionDependencyFactory {
 172  public:
 173   MockPeerConnectionDependencyFactory();
 174   ~MockPeerConnectionDependencyFactory() override;
 175
 176   scoped_refptr<webrtc::PeerConnectionInterface> CreatePeerConnection(
 177       const webrtc::PeerConnectionInterface::RTCConfiguration& config,
 178       const webrtc::MediaConstraintsInterface* constraints,
 179       blink::WebFrame* frame,
 180       webrtc::PeerConnectionObserver* observer) override;
 181   scoped_refptr<webrtc::AudioSourceInterface> CreateLocalAudioSource(
 182       const webrtc::MediaConstraintsInterface* constraints) override;
 183   WebRtcVideoCapturerAdapter* CreateVideoCapturer(
 184       bool is_screen_capture) override;
 185   scoped_refptr<webrtc::VideoSourceInterface> CreateVideoSource(
 186       cricket::VideoCapturer* capturer,
 187       const blink::WebMediaConstraints& constraints) override;
 188   scoped_refptr<WebAudioCapturerSource> CreateWebAudioSource(
 189       blink::WebMediaStreamSource* source) override;
 190   scoped_refptr<webrtc::MediaStreamInterface> CreateLocalMediaStream(
 191       const std::string& label) override;
 192   scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack(
 193       const std::string& id,
 194       webrtc::VideoSourceInterface* source) override;
 195   scoped_refptr<webrtc::VideoTrackInterface> CreateLocalVideoTrack(
 196       const std::string& id,
 197       cricket::VideoCapturer* capturer) override;
 198   webrtc::SessionDescriptionInterface* CreateSessionDescription(
 199       const std::string& type,
 200       const std::string& sdp,
 201       webrtc::SdpParseError* error) override;
 202   webrtc::IceCandidateInterface* CreateIceCandidate(
 203       const std::string& sdp_mid,
 204       int sdp_mline_index,
 205       const std::string& sdp) override;
 206
 207   scoped_refptr<WebRtcAudioCapturer> CreateAudioCapturer(
 208       int render_view_id,
 209       const StreamDeviceInfo& device_info,
 210       const blink::WebMediaConstraints& constraints,
 211       MediaStreamAudioSource* audio_source) override;
 212   void FailToCreateNextAudioCapturer() {
 213     fail_to_create_next_audio_capturer_ = true;
 214   }
 215
 216   void StartLocalAudioTrack(WebRtcLocalAudioTrack* audio_track) override;
 217
 218   MockAudioSource* last_audio_source() { return last_audio_source_.get(); }
 219   MockVideoSource* last_video_source() { return last_video_source_.get(); }
 220
 221  private:
 222   bool fail_to_create_next_audio_capturer_;
 223   scoped_refptr <MockAudioSource> last_audio_source_;
 224   scoped_refptr <MockVideoSource> last_video_source_;
 225
 226   DISALLOW_COPY_AND_ASSIGN(MockPeerConnectionDependencyFactory);
 227 };
 228
 229 }  // namespace content
 230
 231 #endif  // CONTENT_RENDERER_MEDIA_WEBRTC_MOCK_PEER_CONNECTION_DEPENDENCY_FACTORY_H_