Add FakePeerConnectionBase

This provides an intermediate class for defining default, null
implementations of all the PeerConnectionInterface/
PeerConnectionInternal methods. Specific fake PeerConnections then can
inherit from this and only override the methods pertaining to the
scenarios it will be used in.

Bug: webrtc:8764
Change-Id: I7614303b5673747244053b54b839e58aada43d10
Reviewed-on: https://webrtc-review.googlesource.com/43245
Commit-Queue: Steve Anton <steveanton@webrtc.org>
Reviewed-by: Taylor Brandstetter <deadbeef@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#21752}

pc/BUILD.gn

@@ -329,6 +329,7 @@ if (rtc_include_tests) {
       "test/fakeaudiocapturemodule.cc",
       "test/fakeaudiocapturemodule.h",
       "test/fakedatachannelprovider.h",
+      "test/fakepeerconnectionbase.h",
       "test/fakeperiodicvideocapturer.h",
       "test/fakertccertificategenerator.h",
       "test/fakesctptransport.h",

pc/peerconnection.h

@@ -194,7 +194,7 @@ class PeerConnection : public PeerConnectionInternal,
     return factory_->signaling_thread();
   }
 
-  const std::string& session_id() const override { return session_id_; }
+  std::string session_id() const override { return session_id_; }
 
   bool initial_offerer() const override {
     return initial_offerer_ && *initial_offerer_;
@@ -237,7 +237,7 @@ class PeerConnection : public PeerConnectionInternal,
     return rtp_data_channel_;
   }
 
-  const std::vector<rtc::scoped_refptr<DataChannel>>& sctp_data_channels()
+  std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels()
       const override {
     return sctp_data_channels_;
   }

pc/peerconnectioninternal.h

@@ -51,7 +51,7 @@ class PeerConnectionInternal : public PeerConnectionInterface {
   virtual rtc::Thread* signaling_thread() const = 0;
 
   // The SDP session ID as defined by RFC 3264.
-  virtual const std::string& session_id() const = 0;
+  virtual std::string session_id() const = 0;
 
   // Returns true if we were the initial offerer.
   virtual bool initial_offerer() const = 0;
@@ -74,8 +74,8 @@ class PeerConnectionInternal : public PeerConnectionInterface {
   // Only valid when using deprecated RTP data channels.
   virtual cricket::RtpDataChannel* rtp_data_channel() const = 0;
 
-  virtual const std::vector<rtc::scoped_refptr<DataChannel>>&
-  sctp_data_channels() const = 0;
+  virtual std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels()
+      const = 0;
 
   virtual rtc::Optional<std::string> sctp_content_name() const = 0;
   virtual rtc::Optional<std::string> sctp_transport_name() const = 0;

pc/rtcstatscollector_unittest.cc

@@ -45,7 +45,6 @@ using testing::_;
 using testing::Invoke;
 using testing::Return;
 using testing::ReturnNull;
-using testing::ReturnRef;
 using testing::SetArgPointee;
 
 namespace webrtc {
@@ -319,8 +318,8 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
         std::vector<rtc::scoped_refptr<RtpSenderInterface>>()));
     EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(
         std::vector<rtc::scoped_refptr<RtpReceiverInterface>>()));
-    EXPECT_CALL(pc_, sctp_data_channels()).WillRepeatedly(
-        ReturnRef(data_channels_));
+    EXPECT_CALL(pc_, sctp_data_channels())
+        .WillRepeatedly(Return(data_channels_));
     EXPECT_CALL(pc_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(pc_, voice_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(pc_, GetSessionStats(_)).WillRepeatedly(ReturnNull());
@@ -335,8 +334,11 @@ class RTCStatsCollectorTestHelper : public SetSessionDescriptionObserver {
   rtc::Thread* signaling_thread() { return signaling_thread_; }
   cricket::FakeMediaEngine* media_engine() { return media_engine_; }
   MockPeerConnection& pc() { return pc_; }
-  std::vector<rtc::scoped_refptr<DataChannel>>& data_channels() {
-    return data_channels_;
+
+  void AddDataChannel(rtc::scoped_refptr<DataChannel> data_channel) {
+    data_channels_.push_back(data_channel);
+    EXPECT_CALL(pc_, sctp_data_channels())
+        .WillRepeatedly(Return(data_channels_));
   }
 
   // SetSessionDescriptionObserver overrides.
@@ -1025,10 +1027,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCCertificateStatsChain) {
 }
 
 TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
-  test_->data_channels().push_back(
-      new MockDataChannel(
-          0, "MockDataChannel0", DataChannelInterface::kConnecting, "udp",
-          1, 2, 3, 4));
+  test_->AddDataChannel(new MockDataChannel(0, "MockDataChannel0",
+                                            DataChannelInterface::kConnecting,
+                                            "udp", 1, 2, 3, 4));
   RTCDataChannelStats expected_data_channel0("RTCDataChannel_0", 0);
   expected_data_channel0.label = "MockDataChannel0";
   expected_data_channel0.protocol = "udp";
@@ -1039,10 +1040,8 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
   expected_data_channel0.messages_received = 3;
   expected_data_channel0.bytes_received = 4;
 
-  test_->data_channels().push_back(
-      new MockDataChannel(
-          1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp",
-          5, 6, 7, 8));
+  test_->AddDataChannel(new MockDataChannel(
+      1, "MockDataChannel1", DataChannelInterface::kOpen, "tcp", 5, 6, 7, 8));
   RTCDataChannelStats expected_data_channel1("RTCDataChannel_1", 0);
   expected_data_channel1.label = "MockDataChannel1";
   expected_data_channel1.protocol = "tcp";
@@ -1053,10 +1052,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
   expected_data_channel1.messages_received = 7;
   expected_data_channel1.bytes_received = 8;
 
-  test_->data_channels().push_back(
-      new MockDataChannel(
-          2, "MockDataChannel2", DataChannelInterface::kClosing, "udp",
-          9, 10, 11, 12));
+  test_->AddDataChannel(new MockDataChannel(2, "MockDataChannel2",
+                                            DataChannelInterface::kClosing,
+                                            "udp", 9, 10, 11, 12));
   RTCDataChannelStats expected_data_channel2("RTCDataChannel_2", 0);
   expected_data_channel2.label = "MockDataChannel2";
   expected_data_channel2.protocol = "udp";
@@ -1067,10 +1065,9 @@ TEST_F(RTCStatsCollectorTest, CollectRTCDataChannelStats) {
   expected_data_channel2.messages_received = 11;
   expected_data_channel2.bytes_received = 12;
 
-  test_->data_channels().push_back(
-      new MockDataChannel(
-          3, "MockDataChannel3", DataChannelInterface::kClosed, "tcp",
-          13, 14, 15, 16));
+  test_->AddDataChannel(new MockDataChannel(3, "MockDataChannel3",
+                                            DataChannelInterface::kClosed,
+                                            "tcp", 13, 14, 15, 16));
   RTCDataChannelStats expected_data_channel3("RTCDataChannel_3", 0);
   expected_data_channel3.label = "MockDataChannel3";
   expected_data_channel3.protocol = "tcp";

pc/statscollector_unittest.cc

@@ -41,7 +41,6 @@ using testing::Field;
 using testing::Invoke;
 using testing::Return;
 using testing::ReturnNull;
-using testing::ReturnRef;
 using testing::SetArgPointee;
 using webrtc::PeerConnectionInterface;
 using webrtc::StatsReport;
@@ -614,7 +613,7 @@ class StatsCollectorTest : public testing::Test {
     EXPECT_CALL(pc_, video_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(pc_, voice_channel()).WillRepeatedly(ReturnNull());
     EXPECT_CALL(pc_, sctp_data_channels())
-        .WillRepeatedly(ReturnRef(data_channels_));
+        .WillRepeatedly(Return(data_channels_));
     EXPECT_CALL(pc_, GetSenders()).WillRepeatedly(Return(
         std::vector<rtc::scoped_refptr<RtpSenderInterface>>()));
     EXPECT_CALL(pc_, GetReceivers()).WillRepeatedly(Return(
@@ -648,6 +647,8 @@ class StatsCollectorTest : public testing::Test {
 
     data_channels_.push_back(DataChannel::Create(
         &data_channel_provider_, cricket::DCT_SCTP, label, config));
+    EXPECT_CALL(pc_, sctp_data_channels())
+        .WillRepeatedly(Return(data_channels_));
   }
 
   StatsReport* AddCandidateReport(StatsCollector* collector,

pc/test/fakepeerconnectionbase.h

@@ -0,0 +1,319 @@
+/*
+ *  Copyright 2018 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef PC_TEST_FAKEPEERCONNECTIONBASE_H_
+#define PC_TEST_FAKEPEERCONNECTIONBASE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "pc/peerconnectioninternal.h"
+
+namespace webrtc {
+
+// Customized PeerConnection fakes can be created by subclassing
+// FakePeerConnectionBase then overriding the interesting methods. This class
+// takes care of providing default implementations for all the pure virtual
+// functions specified in the interfaces.
+class FakePeerConnectionBase : public PeerConnectionInternal {
+ public:
+  // PeerConnectionInterface implementation.
+
+  rtc::scoped_refptr<StreamCollectionInterface> local_streams() override {
+    return nullptr;
+  }
+
+  rtc::scoped_refptr<StreamCollectionInterface> remote_streams() override {
+    return nullptr;
+  }
+
+  bool AddStream(MediaStreamInterface* stream) override { return false; }
+
+  void RemoveStream(MediaStreamInterface* stream) override {}
+
+  RTCErrorOr<rtc::scoped_refptr<RtpSenderInterface>> AddTrack(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const std::vector<std::string>& stream_labels) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> AddTrack(
+      MediaStreamTrackInterface* track,
+      std::vector<MediaStreamInterface*> streams) override {
+    return nullptr;
+  }
+
+  bool RemoveTrack(RtpSenderInterface* sender) override { return false; }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      rtc::scoped_refptr<MediaStreamTrackInterface> track,
+      const RtpTransceiverInit& init) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      cricket::MediaType media_type) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  RTCErrorOr<rtc::scoped_refptr<RtpTransceiverInterface>> AddTransceiver(
+      cricket::MediaType media_type,
+      const RtpTransceiverInit& init) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  rtc::scoped_refptr<DtmfSenderInterface> CreateDtmfSender(
+      AudioTrackInterface* track) override {
+    return nullptr;
+  }
+
+  rtc::scoped_refptr<RtpSenderInterface> CreateSender(
+      const std::string& kind,
+      const std::string& stream_id) override {
+    return nullptr;
+  }
+
+  std::vector<rtc::scoped_refptr<RtpSenderInterface>> GetSenders()
+      const override {
+    return {};
+  }
+
+  std::vector<rtc::scoped_refptr<RtpReceiverInterface>> GetReceivers()
+      const override {
+    return {};
+  }
+
+  std::vector<rtc::scoped_refptr<RtpTransceiverInterface>> GetTransceivers()
+      const override {
+    return {};
+  }
+
+  bool GetStats(StatsObserver* observer,
+                MediaStreamTrackInterface* track,
+                StatsOutputLevel level) override {
+    return false;
+  }
+
+  void GetStats(RTCStatsCollectorCallback* callback) override {}
+
+  void ClearStatsCache() override {}
+
+  rtc::scoped_refptr<DataChannelInterface> CreateDataChannel(
+      const std::string& label,
+      const DataChannelInit* config) override {
+    return nullptr;
+  }
+
+  const SessionDescriptionInterface* local_description() const override {
+    return nullptr;
+  }
+  const SessionDescriptionInterface* remote_description() const override {
+    return nullptr;
+  }
+
+  const SessionDescriptionInterface* current_local_description()
+      const override {
+    return nullptr;
+  }
+  const SessionDescriptionInterface* current_remote_description()
+      const override {
+    return nullptr;
+  }
+
+  const SessionDescriptionInterface* pending_local_description()
+      const override {
+    return nullptr;
+  }
+  const SessionDescriptionInterface* pending_remote_description()
+      const override {
+    return nullptr;
+  }
+
+  void CreateOffer(CreateSessionDescriptionObserver* observer,
+                   const MediaConstraintsInterface* constraints) override {}
+
+  void CreateOffer(CreateSessionDescriptionObserver* observer,
+                   const RTCOfferAnswerOptions& options) override {}
+
+  void CreateAnswer(CreateSessionDescriptionObserver* observer,
+                    const RTCOfferAnswerOptions& options) override {}
+
+  void CreateAnswer(CreateSessionDescriptionObserver* observer,
+                    const MediaConstraintsInterface* constraints) override {}
+
+  void SetLocalDescription(SetSessionDescriptionObserver* observer,
+                           SessionDescriptionInterface* desc) override {}
+
+  void SetRemoteDescription(SetSessionDescriptionObserver* observer,
+                            SessionDescriptionInterface* desc) override {}
+
+  void SetRemoteDescription(
+      std::unique_ptr<SessionDescriptionInterface> desc,
+      rtc::scoped_refptr<SetRemoteDescriptionObserverInterface> observer)
+      override {}
+
+  bool UpdateIce(const IceServers& configuration,
+                 const MediaConstraintsInterface* constraints) override {
+    return false;
+  }
+
+  bool UpdateIce(const IceServers& configuration) override { return false; }
+
+  RTCConfiguration GetConfiguration() override { return RTCConfiguration(); }
+
+  bool SetConfiguration(const PeerConnectionInterface::RTCConfiguration& config,
+                        RTCError* error) override {
+    return false;
+  }
+
+  bool SetConfiguration(
+      const PeerConnectionInterface::RTCConfiguration& config) override {
+    return false;
+  }
+
+  bool AddIceCandidate(const IceCandidateInterface* candidate) override {
+    return false;
+  }
+
+  bool RemoveIceCandidates(
+      const std::vector<cricket::Candidate>& candidates) override {
+    return false;
+  }
+
+  void RegisterUMAObserver(UMAObserver* observer) override {}
+
+  RTCError SetBitrate(const BitrateParameters& bitrate) override {
+    return RTCError(RTCErrorType::UNSUPPORTED_OPERATION, "Not implemented");
+  }
+
+  void SetBitrateAllocationStrategy(
+      std::unique_ptr<rtc::BitrateAllocationStrategy>
+          bitrate_allocation_strategy) override {}
+
+  void SetAudioPlayout(bool playout) override {}
+
+  void SetAudioRecording(bool recording) override {}
+
+  SignalingState signaling_state() override { return SignalingState::kStable; }
+
+  IceConnectionState ice_connection_state() override {
+    return IceConnectionState::kIceConnectionNew;
+  }
+
+  IceGatheringState ice_gathering_state() override {
+    return IceGatheringState::kIceGatheringNew;
+  }
+
+  bool StartRtcEventLog(rtc::PlatformFile file,
+                        int64_t max_size_bytes) override {
+    return false;
+  }
+
+  bool StartRtcEventLog(std::unique_ptr<RtcEventLogOutput> output,
+                        int64_t output_period_ms) override {
+    return false;
+  }
+
+  void StopRtcEventLog() override {}
+
+  void Close() override {}
+
+  // PeerConnectionInternal implementation.
+
+  rtc::Thread* network_thread() const override { return nullptr; }
+  rtc::Thread* worker_thread() const override { return nullptr; }
+  rtc::Thread* signaling_thread() const override { return nullptr; }
+
+  std::string session_id() const override { return ""; }
+
+  bool initial_offerer() const override { return false; }
+
+  cricket::VoiceChannel* voice_channel() const override { return nullptr; }
+
+  cricket::VideoChannel* video_channel() const override { return nullptr; }
+
+  std::vector<
+      rtc::scoped_refptr<RtpTransceiverProxyWithInternal<RtpTransceiver>>>
+  GetTransceiversForTesting() const override {
+    return {};
+  }
+
+  bool GetLocalTrackIdBySsrc(uint32_t ssrc, std::string* track_id) override {
+    return false;
+  }
+  bool GetRemoteTrackIdBySsrc(uint32_t ssrc, std::string* track_id) override {
+    return false;
+  }
+
+  sigslot::signal1<DataChannel*>& SignalDataChannelCreated() override {
+    return SignalDataChannelCreated_;
+  }
+
+  cricket::RtpDataChannel* rtp_data_channel() const override { return nullptr; }
+
+  std::vector<rtc::scoped_refptr<DataChannel>> sctp_data_channels()
+      const override {
+    return {};
+  }
+
+  rtc::Optional<std::string> sctp_content_name() const override {
+    return rtc::nullopt;
+  }
+
+  rtc::Optional<std::string> sctp_transport_name() const override {
+    return rtc::nullopt;
+  }
+
+  std::unique_ptr<SessionStats> GetSessionStats_s() override { return nullptr; }
+
+  std::unique_ptr<SessionStats> GetSessionStats(
+      const ChannelNamePairs& channel_name_pairs) override {
+    return nullptr;
+  }
+
+  Call::Stats GetCallStats() override { return Call::Stats(); }
+
+  bool GetLocalCertificate(
+      const std::string& transport_name,
+      rtc::scoped_refptr<rtc::RTCCertificate>* certificate) override {
+    return false;
+  }
+
+  std::unique_ptr<rtc::SSLCertificate> GetRemoteSSLCertificate(
+      const std::string& transport_name) override {
+    return nullptr;
+  }
+
+  bool IceRestartPending(const std::string& content_name) const override {
+    return false;
+  }
+
+  bool NeedsIceRestart(const std::string& content_name) const override {
+    return false;
+  }
+
+  bool GetSslRole(const std::string& content_name,
+                  rtc::SSLRole* role) override {
+    return false;
+  }
+
+ protected:
+  sigslot::signal1<DataChannel*> SignalDataChannelCreated_;
+};
+
+}  // namespace webrtc
+
+#endif  // PC_TEST_FAKEPEERCONNECTIONBASE_H_

pc/test/mock_peerconnection.h

@@ -60,7 +60,7 @@ class MockPeerConnection
   MOCK_CONST_METHOD0(GetReceivers,
                      std::vector<rtc::scoped_refptr<RtpReceiverInterface>>());
   MOCK_CONST_METHOD0(sctp_data_channels,
-                     const std::vector<rtc::scoped_refptr<DataChannel>>&());
+                     std::vector<rtc::scoped_refptr<DataChannel>>());
   MOCK_CONST_METHOD0(voice_channel, cricket::VoiceChannel*());
   MOCK_CONST_METHOD0(video_channel, cricket::VideoChannel*());
   // Libjingle uses "local" for a outgoing track, and "remote" for a incoming