src/third_party/libjingle/source/talk/app/webrtc/test/peerconnectiontestwrapper.cc

   1 /*
   2  * libjingle
   3  * Copyright 2013, Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "talk/app/webrtc/fakeportallocatorfactory.h"
  29 #include "talk/app/webrtc/test/fakedtlsidentityservice.h"
  30 #include "talk/app/webrtc/test/fakeperiodicvideocapturer.h"
  31 #include "talk/app/webrtc/test/mockpeerconnectionobservers.h"
  32 #include "talk/app/webrtc/test/peerconnectiontestwrapper.h"
  33 #include "talk/app/webrtc/videosourceinterface.h"
  34 #include "webrtc/base/gunit.h"
  35
  36 static const char kStreamLabelBase[] = "stream_label";
  37 static const char kVideoTrackLabelBase[] = "video_track";
  38 static const char kAudioTrackLabelBase[] = "audio_track";
  39 static const int kMaxWait = 10000;
  40 static const int kTestAudioFrameCount = 3;
  41 static const int kTestVideoFrameCount = 3;
  42
  43 using webrtc::FakeConstraints;
  44 using webrtc::FakeVideoTrackRenderer;
  45 using webrtc::IceCandidateInterface;
  46 using webrtc::MediaConstraintsInterface;
  47 using webrtc::MediaStreamInterface;
  48 using webrtc::MockSetSessionDescriptionObserver;
  49 using webrtc::PeerConnectionInterface;
  50 using webrtc::SessionDescriptionInterface;
  51 using webrtc::VideoTrackInterface;
  52
  53 void PeerConnectionTestWrapper::Connect(PeerConnectionTestWrapper* caller,
  54                                         PeerConnectionTestWrapper* callee) {
  55   caller->SignalOnIceCandidateReady.connect(
  56       callee, &PeerConnectionTestWrapper::AddIceCandidate);
  57   callee->SignalOnIceCandidateReady.connect(
  58       caller, &PeerConnectionTestWrapper::AddIceCandidate);
  59
  60   caller->SignalOnSdpReady.connect(
  61       callee, &PeerConnectionTestWrapper::ReceiveOfferSdp);
  62   callee->SignalOnSdpReady.connect(
  63       caller, &PeerConnectionTestWrapper::ReceiveAnswerSdp);
  64 }
  65
  66 PeerConnectionTestWrapper::PeerConnectionTestWrapper(const std::string& name)
  67     : name_(name) {}
  68
  69 PeerConnectionTestWrapper::~PeerConnectionTestWrapper() {}
  70
  71 bool PeerConnectionTestWrapper::CreatePc(
  72   const MediaConstraintsInterface* constraints) {
  73   allocator_factory_ = webrtc::FakePortAllocatorFactory::Create();
  74   if (!allocator_factory_) {
  75     return false;
  76   }
  77
  78   fake_audio_capture_module_ = FakeAudioCaptureModule::Create(
  79       rtc::Thread::Current());
  80   if (fake_audio_capture_module_ == NULL) {
  81     return false;
  82   }
  83
  84   peer_connection_factory_ = webrtc::CreatePeerConnectionFactory(
  85       rtc::Thread::Current(), rtc::Thread::Current(),
  86       fake_audio_capture_module_, NULL, NULL);
  87   if (!peer_connection_factory_) {
  88     return false;
  89   }
  90
  91   // CreatePeerConnection with IceServers.
  92   webrtc::PeerConnectionInterface::IceServers ice_servers;
  93   webrtc::PeerConnectionInterface::IceServer ice_server;
  94   ice_server.uri = "stun:stun.l.google.com:19302";
  95   ice_servers.push_back(ice_server);
  96   FakeIdentityService* dtls_service =
  97       rtc::SSLStreamAdapter::HaveDtlsSrtp() ?
  98           new FakeIdentityService() : NULL;
  99   peer_connection_ = peer_connection_factory_->CreatePeerConnection(
 100       ice_servers, constraints, allocator_factory_.get(), dtls_service, this);
 101
 102   return peer_connection_.get() != NULL;
 103 }
 104
 105 rtc::scoped_refptr<webrtc::DataChannelInterface>
 106 PeerConnectionTestWrapper::CreateDataChannel(
 107     const std::string& label,
 108     const webrtc::DataChannelInit& init) {
 109   return peer_connection_->CreateDataChannel(label, &init);
 110 }
 111
 112 void PeerConnectionTestWrapper::OnAddStream(MediaStreamInterface* stream) {
 113   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 114                << ": OnAddStream";
 115   // TODO(ronghuawu): support multiple streams.
 116   if (stream->GetVideoTracks().size() > 0) {
 117     renderer_.reset(new FakeVideoTrackRenderer(stream->GetVideoTracks()[0]));
 118   }
 119 }
 120
 121 void PeerConnectionTestWrapper::OnIceCandidate(
 122     const IceCandidateInterface* candidate) {
 123   std::string sdp;
 124   EXPECT_TRUE(candidate->ToString(&sdp));
 125   // Give the user a chance to modify sdp for testing.
 126   SignalOnIceCandidateCreated(&sdp);
 127   SignalOnIceCandidateReady(candidate->sdp_mid(), candidate->sdp_mline_index(),
 128                             sdp);
 129 }
 130
 131 void PeerConnectionTestWrapper::OnDataChannel(
 132     webrtc::DataChannelInterface* data_channel) {
 133   SignalOnDataChannel(data_channel);
 134 }
 135
 136 void PeerConnectionTestWrapper::OnSuccess(SessionDescriptionInterface* desc) {
 137   // This callback should take the ownership of |desc|.
 138   rtc::scoped_ptr<SessionDescriptionInterface> owned_desc(desc);
 139   std::string sdp;
 140   EXPECT_TRUE(desc->ToString(&sdp));
 141
 142   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 143                << ": " << desc->type() << " sdp created: " << sdp;
 144
 145   // Give the user a chance to modify sdp for testing.
 146   SignalOnSdpCreated(&sdp);
 147
 148   SetLocalDescription(desc->type(), sdp);
 149
 150   SignalOnSdpReady(sdp);
 151 }
 152
 153 void PeerConnectionTestWrapper::CreateOffer(
 154     const MediaConstraintsInterface* constraints) {
 155   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 156                << ": CreateOffer.";
 157   peer_connection_->CreateOffer(this, constraints);
 158 }
 159
 160 void PeerConnectionTestWrapper::CreateAnswer(
 161     const MediaConstraintsInterface* constraints) {
 162   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 163                << ": CreateAnswer.";
 164   peer_connection_->CreateAnswer(this, constraints);
 165 }
 166
 167 void PeerConnectionTestWrapper::ReceiveOfferSdp(const std::string& sdp) {
 168   SetRemoteDescription(SessionDescriptionInterface::kOffer, sdp);
 169   CreateAnswer(NULL);
 170 }
 171
 172 void PeerConnectionTestWrapper::ReceiveAnswerSdp(const std::string& sdp) {
 173   SetRemoteDescription(SessionDescriptionInterface::kAnswer, sdp);
 174 }
 175
 176 void PeerConnectionTestWrapper::SetLocalDescription(const std::string& type,
 177                                                     const std::string& sdp) {
 178   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 179                << ": SetLocalDescription " << type << " " << sdp;
 180
 181   rtc::scoped_refptr<MockSetSessionDescriptionObserver>
 182       observer(new rtc::RefCountedObject<
 183                    MockSetSessionDescriptionObserver>());
 184   peer_connection_->SetLocalDescription(
 185       observer, webrtc::CreateSessionDescription(type, sdp, NULL));
 186 }
 187
 188 void PeerConnectionTestWrapper::SetRemoteDescription(const std::string& type,
 189                                                      const std::string& sdp) {
 190   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 191                << ": SetRemoteDescription " << type << " " << sdp;
 192
 193   rtc::scoped_refptr<MockSetSessionDescriptionObserver>
 194       observer(new rtc::RefCountedObject<
 195                    MockSetSessionDescriptionObserver>());
 196   peer_connection_->SetRemoteDescription(
 197       observer, webrtc::CreateSessionDescription(type, sdp, NULL));
 198 }
 199
 200 void PeerConnectionTestWrapper::AddIceCandidate(const std::string& sdp_mid,
 201                                                 int sdp_mline_index,
 202                                                 const std::string& candidate) {
 203   rtc::scoped_ptr<webrtc::IceCandidateInterface> owned_candidate(
 204       webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, candidate, NULL));
 205   EXPECT_TRUE(peer_connection_->AddIceCandidate(owned_candidate.get()));
 206 }
 207
 208 void PeerConnectionTestWrapper::WaitForCallEstablished() {
 209   WaitForConnection();
 210   WaitForAudio();
 211   WaitForVideo();
 212 }
 213
 214 void PeerConnectionTestWrapper::WaitForConnection() {
 215   EXPECT_TRUE_WAIT(CheckForConnection(), kMaxWait);
 216   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 217                << ": Connected.";
 218 }
 219
 220 bool PeerConnectionTestWrapper::CheckForConnection() {
 221   return (peer_connection_->ice_connection_state() ==
 222           PeerConnectionInterface::kIceConnectionConnected) ||
 223          (peer_connection_->ice_connection_state() ==
 224           PeerConnectionInterface::kIceConnectionCompleted);
 225 }
 226
 227 void PeerConnectionTestWrapper::WaitForAudio() {
 228   EXPECT_TRUE_WAIT(CheckForAudio(), kMaxWait);
 229   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 230                << ": Got enough audio frames.";
 231 }
 232
 233 bool PeerConnectionTestWrapper::CheckForAudio() {
 234   return (fake_audio_capture_module_->frames_received() >=
 235           kTestAudioFrameCount);
 236 }
 237
 238 void PeerConnectionTestWrapper::WaitForVideo() {
 239   EXPECT_TRUE_WAIT(CheckForVideo(), kMaxWait);
 240   LOG(LS_INFO) << "PeerConnectionTestWrapper " << name_
 241                << ": Got enough video frames.";
 242 }
 243
 244 bool PeerConnectionTestWrapper::CheckForVideo() {
 245   if (!renderer_) {
 246     return false;
 247   }
 248   return (renderer_->num_rendered_frames() >= kTestVideoFrameCount);
 249 }
 250
 251 void PeerConnectionTestWrapper::GetAndAddUserMedia(
 252     bool audio, const webrtc::FakeConstraints& audio_constraints,
 253     bool video, const webrtc::FakeConstraints& video_constraints) {
 254   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
 255       GetUserMedia(audio, audio_constraints, video, video_constraints);
 256   EXPECT_TRUE(peer_connection_->AddStream(stream, NULL));
 257 }
 258
 259 rtc::scoped_refptr<webrtc::MediaStreamInterface>
 260     PeerConnectionTestWrapper::GetUserMedia(
 261         bool audio, const webrtc::FakeConstraints& audio_constraints,
 262         bool video, const webrtc::FakeConstraints& video_constraints) {
 263   std::string label = kStreamLabelBase +
 264       rtc::ToString<int>(
 265           static_cast<int>(peer_connection_->local_streams()->count()));
 266   rtc::scoped_refptr<webrtc::MediaStreamInterface> stream =
 267       peer_connection_factory_->CreateLocalMediaStream(label);
 268
 269   if (audio) {
 270     FakeConstraints constraints = audio_constraints;
 271     // Disable highpass filter so that we can get all the test audio frames.
 272     constraints.AddMandatory(
 273         MediaConstraintsInterface::kHighpassFilter, false);
 274     rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
 275         peer_connection_factory_->CreateAudioSource(&constraints);
 276     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
 277         peer_connection_factory_->CreateAudioTrack(kAudioTrackLabelBase,
 278                                                    source));
 279     stream->AddTrack(audio_track);
 280   }
 281
 282   if (video) {
 283     // Set max frame rate to 10fps to reduce the risk of the tests to be flaky.
 284     FakeConstraints constraints = video_constraints;
 285     constraints.SetMandatoryMaxFrameRate(10);
 286
 287     rtc::scoped_refptr<webrtc::VideoSourceInterface> source =
 288         peer_connection_factory_->CreateVideoSource(
 289             new webrtc::FakePeriodicVideoCapturer(), &constraints);
 290     std::string videotrack_label = label + kVideoTrackLabelBase;
 291     rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
 292         peer_connection_factory_->CreateVideoTrack(videotrack_label, source));
 293
 294     stream->AddTrack(video_track);
 295   }
 296   return stream;
 297 }