Unify Transport and newapi::Transport interfaces.

webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc

Index: webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
index d33b086eb25f39479c2740061bc170cba4d0a87a..edcb84d90fc26f629eb3ca5596357a4e495b3bba 100644
--- a/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtp_sender_unittest.cc
@@ -78,7 +78,7 @@ class LoopbackTransportTest : public webrtc::Transport {
   ~LoopbackTransportTest() {
     STLDeleteContainerPointers(sent_packets_.begin(), sent_packets_.end());
   }
-  int SendPacket(const void *data, size_t len) override {
+  bool SendRtp(const uint8_t *data, size_t len) override {
     packets_sent_++;
     rtc::Buffer* buffer =
         new rtc::Buffer(reinterpret_cast<const uint8_t*>(data), len);
@@ -86,10 +86,10 @@ class LoopbackTransportTest : public webrtc::Transport {
     last_sent_packet_len_ = len;
     total_bytes_sent_ += len;
     sent_packets_.push_back(buffer);
-    return static_cast<int>(len);
+    return true;
   }
-  int SendRTCPPacket(const void* data, size_t len) override {
-    return -1;
+  bool SendRtcp(const uint8_t* data, size_t len) override {
+    return false;
   }
   int packets_sent_;
   size_t last_sent_packet_len_;
@@ -864,26 +864,26 @@ TEST_F(RtpSenderTest, SendRedundantPayloads) {
   // Send 10 packets of increasing size.
   for (size_t i = 0; i < kNumPayloadSizes; ++i) {
     int64_t capture_time_ms = fake_clock_.TimeInMilliseconds();
-    EXPECT_CALL(transport, SendPacket(_, _)).WillOnce(testing::ReturnArg<1>());
+    EXPECT_CALL(transport, SendRtp(_, _)).WillOnce(testing::Return(true));
     SendPacket(capture_time_ms, kPayloadSizes[i]);
     rtp_sender_->TimeToSendPacket(seq_num++, capture_time_ms, false);
     fake_clock_.AdvanceTimeMilliseconds(33);
   }
   // The amount of padding to send it too small to send a payload packet.
-  EXPECT_CALL(transport, SendPacket(_, kMaxPaddingSize + rtp_header_len))
-      .WillOnce(testing::ReturnArg<1>());
+  EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len))
+      .WillOnce(testing::Return(true));
   EXPECT_EQ(kMaxPaddingSize, rtp_sender_->TimeToSendPadding(49));
 
   EXPECT_CALL(transport,
-              SendPacket(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize))
-      .WillOnce(testing::ReturnArg<1>());
+              SendRtp(_, kPayloadSizes[0] + rtp_header_len + kRtxHeaderSize))
+      .WillOnce(testing::Return(true));
   EXPECT_EQ(kPayloadSizes[0], rtp_sender_->TimeToSendPadding(500));
 
-  EXPECT_CALL(transport, SendPacket(_, kPayloadSizes[kNumPayloadSizes - 1] +
+  EXPECT_CALL(transport, SendRtp(_, kPayloadSizes[kNumPayloadSizes - 1] +
                                            rtp_header_len + kRtxHeaderSize))
-      .WillOnce(testing::ReturnArg<1>());
-  EXPECT_CALL(transport, SendPacket(_, kMaxPaddingSize + rtp_header_len))
-      .WillOnce(testing::ReturnArg<1>());
+      .WillOnce(testing::Return(true));
+  EXPECT_CALL(transport, SendRtp(_, kMaxPaddingSize + rtp_header_len))
+      .WillOnce(testing::Return(true));
   EXPECT_EQ(kPayloadSizes[kNumPayloadSizes - 1] + kMaxPaddingSize,
             rtp_sender_->TimeToSendPadding(999));
 }