content/renderer/media/mock_peer_connection_impl.cc

   1 // Copyright (c) 2012 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/mock_peer_connection_impl.h"
   6
   7 #include <vector>
   8
   9 #include "base/logging.h"
  10 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
  11
  12 using testing::_;
  13 using webrtc::AudioTrackInterface;
  14 using webrtc::CreateSessionDescriptionObserver;
  15 using webrtc::DtmfSenderInterface;
  16 using webrtc::DtmfSenderObserverInterface;
  17 using webrtc::IceCandidateInterface;
  18 using webrtc::MediaConstraintsInterface;
  19 using webrtc::MediaStreamInterface;
  20 using webrtc::PeerConnectionInterface;
  21 using webrtc::SessionDescriptionInterface;
  22 using webrtc::SetSessionDescriptionObserver;
  23
  24 namespace content {
  25
  26 class MockStreamCollection : public webrtc::StreamCollectionInterface {
  27  public:
  28   size_t count() override { return streams_.size(); }
  29   MediaStreamInterface* at(size_t index) override { return streams_[index]; }
  30   MediaStreamInterface* find(const std::string& label) override {
  31     for (size_t i = 0; i < streams_.size(); ++i) {
  32       if (streams_[i]->label() == label)
  33         return streams_[i];
  34     }
  35     return NULL;
  36   }
  37   webrtc::MediaStreamTrackInterface* FindAudioTrack(
  38       const std::string& id) override {
  39     for (size_t i = 0; i < streams_.size(); ++i) {
  40       webrtc::MediaStreamTrackInterface* track =
  41           streams_.at(i)->FindAudioTrack(id);
  42       if (track)
  43         return track;
  44     }
  45     return NULL;
  46   }
  47   webrtc::MediaStreamTrackInterface* FindVideoTrack(
  48       const std::string& id) override {
  49     for (size_t i = 0; i < streams_.size(); ++i) {
  50       webrtc::MediaStreamTrackInterface* track =
  51           streams_.at(i)->FindVideoTrack(id);
  52       if (track)
  53         return track;
  54     }
  55     return NULL;
  56   }
  57   void AddStream(MediaStreamInterface* stream) {
  58     streams_.push_back(stream);
  59   }
  60   void RemoveStream(MediaStreamInterface* stream) {
  61     StreamVector::iterator it = streams_.begin();
  62     for (; it != streams_.end(); ++it) {
  63       if (it->get() == stream) {
  64         streams_.erase(it);
  65         break;
  66       }
  67     }
  68   }
  69
  70  protected:
  71   ~MockStreamCollection() override {}
  72
  73  private:
  74   typedef std::vector<rtc::scoped_refptr<MediaStreamInterface> >
  75       StreamVector;
  76   StreamVector streams_;
  77 };
  78
  79 class MockDataChannel : public webrtc::DataChannelInterface {
  80  public:
  81   MockDataChannel(const std::string& label,
  82                   const webrtc::DataChannelInit* config)
  83       : label_(label),
  84         reliable_(config->reliable),
  85         state_(webrtc::DataChannelInterface::kConnecting),
  86         config_(*config) {
  87   }
  88
  89   void RegisterObserver(webrtc::DataChannelObserver* observer) override {}
  90
  91   void UnregisterObserver() override {}
  92
  93   std::string label() const override { return label_; }
  94
  95   bool reliable() const override { return reliable_; }
  96
  97   bool ordered() const override { return config_.ordered; }
  98
  99   unsigned short maxRetransmitTime() const override {
 100     return config_.maxRetransmitTime;
 101   }
 102
 103   unsigned short maxRetransmits() const override {
 104     return config_.maxRetransmits;
 105   }
 106
 107   std::string protocol() const override { return config_.protocol; }
 108
 109   bool negotiated() const override { return config_.negotiated; }
 110
 111   int id() const override {
 112     NOTIMPLEMENTED();
 113     return 0;
 114   }
 115
 116   DataState state() const override { return state_; }
 117
 118   uint64 buffered_amount() const override {
 119     NOTIMPLEMENTED();
 120     return 0;
 121   }
 122
 123   void Close() override { state_ = webrtc::DataChannelInterface::kClosing; }
 124
 125   bool Send(const webrtc::DataBuffer& buffer) override {
 126     return state_ == webrtc::DataChannelInterface::kOpen;
 127   }
 128
 129  protected:
 130   ~MockDataChannel() override {}
 131
 132  private:
 133   std::string label_;
 134   bool reliable_;
 135   webrtc::DataChannelInterface::DataState state_;
 136   webrtc::DataChannelInit config_;
 137 };
 138
 139 class MockDtmfSender : public DtmfSenderInterface {
 140  public:
 141   explicit MockDtmfSender(AudioTrackInterface* track)
 142       : track_(track),
 143         observer_(NULL),
 144         duration_(0),
 145         inter_tone_gap_(0) {}
 146   void RegisterObserver(DtmfSenderObserverInterface* observer) override {
 147     observer_ = observer;
 148   }
 149   void UnregisterObserver() override { observer_ = NULL; }
 150   bool CanInsertDtmf() override { return true; }
 151   bool InsertDtmf(const std::string& tones,
 152                   int duration,
 153                   int inter_tone_gap) override {
 154     tones_ = tones;
 155     duration_ = duration;
 156     inter_tone_gap_ = inter_tone_gap;
 157     return true;
 158   }
 159   const AudioTrackInterface* track() const override { return track_.get(); }
 160   std::string tones() const override { return tones_; }
 161   int duration() const override { return duration_; }
 162   int inter_tone_gap() const override { return inter_tone_gap_; }
 163
 164  protected:
 165   ~MockDtmfSender() override {}
 166
 167  private:
 168   rtc::scoped_refptr<AudioTrackInterface> track_;
 169   DtmfSenderObserverInterface* observer_;
 170   std::string tones_;
 171   int duration_;
 172   int inter_tone_gap_;
 173 };
 174
 175 const char MockPeerConnectionImpl::kDummyOffer[] = "dummy offer";
 176 const char MockPeerConnectionImpl::kDummyAnswer[] = "dummy answer";
 177
 178 MockPeerConnectionImpl::MockPeerConnectionImpl(
 179     MockPeerConnectionDependencyFactory* factory)
 180     : dependency_factory_(factory),
 181       local_streams_(new rtc::RefCountedObject<MockStreamCollection>),
 182       remote_streams_(new rtc::RefCountedObject<MockStreamCollection>),
 183       hint_audio_(false),
 184       hint_video_(false),
 185       getstats_result_(true),
 186       sdp_mline_index_(-1) {
 187   ON_CALL(*this, SetLocalDescription(_, _)).WillByDefault(testing::Invoke(
 188       this, &MockPeerConnectionImpl::SetLocalDescriptionWorker));
 189   ON_CALL(*this, SetRemoteDescription(_, _)).WillByDefault(testing::Invoke(
 190       this, &MockPeerConnectionImpl::SetRemoteDescriptionWorker));
 191 }
 192
 193 MockPeerConnectionImpl::~MockPeerConnectionImpl() {}
 194
 195 rtc::scoped_refptr<webrtc::StreamCollectionInterface>
 196 MockPeerConnectionImpl::local_streams() {
 197   return local_streams_;
 198 }
 199
 200 rtc::scoped_refptr<webrtc::StreamCollectionInterface>
 201 MockPeerConnectionImpl::remote_streams() {
 202   return remote_streams_;
 203 }
 204
 205 bool MockPeerConnectionImpl::AddStream(
 206     MediaStreamInterface* local_stream,
 207     const MediaConstraintsInterface* constraints) {
 208   DCHECK(stream_label_.empty());
 209   stream_label_ = local_stream->label();
 210   local_streams_->AddStream(local_stream);
 211   return true;
 212 }
 213
 214 void MockPeerConnectionImpl::RemoveStream(
 215     MediaStreamInterface* local_stream) {
 216   DCHECK_EQ(stream_label_, local_stream->label());
 217   stream_label_.clear();
 218   local_streams_->RemoveStream(local_stream);
 219 }
 220
 221 rtc::scoped_refptr<DtmfSenderInterface>
 222 MockPeerConnectionImpl::CreateDtmfSender(AudioTrackInterface* track) {
 223   if (!track) {
 224     return NULL;
 225   }
 226   return new rtc::RefCountedObject<MockDtmfSender>(track);
 227 }
 228
 229 rtc::scoped_refptr<webrtc::DataChannelInterface>
 230 MockPeerConnectionImpl::CreateDataChannel(const std::string& label,
 231                       const webrtc::DataChannelInit* config) {
 232   return new rtc::RefCountedObject<MockDataChannel>(label, config);
 233 }
 234
 235 bool MockPeerConnectionImpl::GetStats(
 236     webrtc::StatsObserver* observer,
 237     webrtc::MediaStreamTrackInterface* track,
 238     StatsOutputLevel level) {
 239   if (!getstats_result_)
 240     return false;
 241
 242   DCHECK_EQ(kStatsOutputLevelStandard, level);
 243   webrtc::StatsReport report1, report2;
 244   report1.id = "1234";
 245   report1.type = "ssrc";
 246   report1.timestamp = 42;
 247   report1.values.push_back(
 248       webrtc::StatsReport::Value(
 249           webrtc::StatsReport::kStatsValueNameFingerprint,
 250           "trackvalue"));
 251
 252   webrtc::StatsReports reports;
 253   reports.push_back(&report1);
 254
 255   // If selector is given, we pass back one report.
 256   // If selector is not given, we pass back two.
 257   if (!track) {
 258     report2.id = "nontrack";
 259     report2.type = "generic";
 260     report2.timestamp = 44;
 261     report2.values.push_back(
 262         webrtc::StatsReport::Value(
 263             webrtc::StatsReport::kStatsValueNameFingerprintAlgorithm,
 264             "somevalue"));
 265     reports.push_back(&report2);
 266   }
 267
 268   // Note that the callback is synchronous, not asynchronous; it will
 269   // happen before the request call completes.
 270   observer->OnComplete(reports);
 271
 272   return true;
 273 }
 274
 275 const webrtc::SessionDescriptionInterface*
 276 MockPeerConnectionImpl::local_description() const {
 277   return local_desc_.get();
 278 }
 279
 280 const webrtc::SessionDescriptionInterface*
 281 MockPeerConnectionImpl::remote_description() const {
 282   return remote_desc_.get();
 283 }
 284
 285 void MockPeerConnectionImpl::AddRemoteStream(MediaStreamInterface* stream) {
 286   remote_streams_->AddStream(stream);
 287 }
 288
 289 void MockPeerConnectionImpl::CreateOffer(
 290     CreateSessionDescriptionObserver* observer,
 291     const MediaConstraintsInterface* constraints) {
 292   DCHECK(observer);
 293   created_sessiondescription_.reset(
 294       dependency_factory_->CreateSessionDescription("unknown", kDummyOffer,
 295                                                     NULL));
 296 }
 297
 298 void MockPeerConnectionImpl::CreateAnswer(
 299     CreateSessionDescriptionObserver* observer,
 300     const MediaConstraintsInterface* constraints) {
 301   DCHECK(observer);
 302   created_sessiondescription_.reset(
 303       dependency_factory_->CreateSessionDescription("unknown", kDummyAnswer,
 304                                                     NULL));
 305 }
 306
 307 void MockPeerConnectionImpl::SetLocalDescriptionWorker(
 308     SetSessionDescriptionObserver* observer,
 309     SessionDescriptionInterface* desc) {
 310   desc->ToString(&description_sdp_);
 311   local_desc_.reset(desc);
 312 }
 313
 314 void MockPeerConnectionImpl::SetRemoteDescriptionWorker(
 315     SetSessionDescriptionObserver* observer,
 316     SessionDescriptionInterface* desc) {
 317   desc->ToString(&description_sdp_);
 318   remote_desc_.reset(desc);
 319 }
 320
 321 bool MockPeerConnectionImpl::UpdateIce(
 322     const IceServers& configuration,
 323     const MediaConstraintsInterface* constraints) {
 324   return true;
 325 }
 326
 327 bool MockPeerConnectionImpl::AddIceCandidate(
 328     const IceCandidateInterface* candidate) {
 329   sdp_mid_ = candidate->sdp_mid();
 330   sdp_mline_index_ = candidate->sdp_mline_index();
 331   return candidate->ToString(&ice_sdp_);
 332 }
 333
 334 void MockPeerConnectionImpl::RegisterUMAObserver(
 335     webrtc::UMAObserver* observer) {
 336   NOTIMPLEMENTED();
 337 }
 338
 339 }  // namespace content