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