Interface RTCRtpReceiver and RTCPeerConnection.getReceivers() added.

content/renderer/media/mock_peer_connection_impl.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/mock_peer_connection_impl.h"
 
 #include <stddef.h>
 
 #include <vector>
 
 #include "base/logging.h"
 #include "content/renderer/media/mock_data_channel_impl.h"
 #include "content/renderer/media/webrtc/mock_peer_connection_dependency_factory.h"
+#include "third_party/webrtc/api/rtpreceiverinterface.h"
+#include "third_party/webrtc/base/refcountedobject.h"
 
 using testing::_;
 using webrtc::AudioTrackInterface;
 using webrtc::CreateSessionDescriptionObserver;
 using webrtc::DtmfSenderInterface;
 using webrtc::DtmfSenderObserverInterface;
 using webrtc::IceCandidateInterface;
 using webrtc::MediaStreamInterface;
 using webrtc::PeerConnectionInterface;
 using webrtc::SessionDescriptionInterface;
@@ skipping 83 matching lines @@
   ~MockDtmfSender() override {}
 
  private:
   rtc::scoped_refptr<AudioTrackInterface> track_;
   DtmfSenderObserverInterface* observer_;
   std::string tones_;
   int duration_;
   int inter_tone_gap_;
 };
 
+class FakeRtpReceiver
+    : public rtc::RefCountedObject<webrtc::RtpReceiverInterface> {
+ public:
+  FakeRtpReceiver(rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track)
+      : track_(track) {}
+
+  rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track() const override {
+    return track_;
+  }
+
+  cricket::MediaType media_type() const override {
+    NOTIMPLEMENTED();
+    return cricket::MEDIA_TYPE_AUDIO;
+  }
+
+  std::string id() const override {
+    NOTIMPLEMENTED();
+    return "";
+  }
+
+  webrtc::RtpParameters GetParameters() const override {
+    NOTIMPLEMENTED();
+    return webrtc::RtpParameters();
+  }
+
+  bool SetParameters(const webrtc::RtpParameters& parameters) override {
+    NOTIMPLEMENTED();
+    return false;
+  }
+
+  void SetObserver(webrtc::RtpReceiverObserverInterface* observer) override {
+    NOTIMPLEMENTED();
+  }
+
+ private:
+  rtc::scoped_refptr<webrtc::MediaStreamTrackInterface> track_;
+};
+
 const char MockPeerConnectionImpl::kDummyOffer[] = "dummy offer";
 const char MockPeerConnectionImpl::kDummyAnswer[] = "dummy answer";
 
 MockPeerConnectionImpl::MockPeerConnectionImpl(
     MockPeerConnectionDependencyFactory* factory,
     webrtc::PeerConnectionObserver* observer)
     : dependency_factory_(factory),
       local_streams_(new rtc::RefCountedObject<MockStreamCollection>),
       remote_streams_(new rtc::RefCountedObject<MockStreamCollection>),
       hint_audio_(false),
@@ skipping 34 matching lines @@
 }
 
 rtc::scoped_refptr<DtmfSenderInterface>
 MockPeerConnectionImpl::CreateDtmfSender(AudioTrackInterface* track) {
   if (!track) {
     return NULL;
   }
   return new rtc::RefCountedObject<MockDtmfSender>(track);
 }
 
+std::vector<rtc::scoped_refptr<webrtc::RtpReceiverInterface>>
+MockPeerConnectionImpl::GetReceivers() const {
+  std::vector<rtc::scoped_refptr<webrtc::RtpReceiverInterface>> receivers;
+  for (size_t i = 0; i < remote_streams_->count(); ++i) {
+    for (const auto& audio_track : remote_streams_->at(i)->GetAudioTracks()) {
+      receivers.push_back(new FakeRtpReceiver(audio_track));
+    }
+    for (const auto& video_track : remote_streams_->at(i)->GetVideoTracks()) {
+      receivers.push_back(new FakeRtpReceiver(video_track));
+    }
+  }
+  return receivers;
+}
+
 rtc::scoped_refptr<webrtc::DataChannelInterface>
 MockPeerConnectionImpl::CreateDataChannel(const std::string& label,
                       const webrtc::DataChannelInit* config) {
   return new rtc::RefCountedObject<MockDataChannel>(label, config);
 }
 
 bool MockPeerConnectionImpl::GetStats(
     webrtc::StatsObserver* observer,
     webrtc::MediaStreamTrackInterface* track,
     StatsOutputLevel level) {
@@ skipping 101 matching lines @@
   sdp_mline_index_ = candidate->sdp_mline_index();
   return candidate->ToString(&ice_sdp_);
 }
 
 void MockPeerConnectionImpl::RegisterUMAObserver(
     webrtc::UMAObserver* observer) {
   NOTIMPLEMENTED();
 }
 
 }  // namespace content