Refactor: simplify interface of SenderRtcpSession and CastTransport.

media/cast/net/rtcp/rtcp_unittest.cc

Index: media/cast/net/rtcp/rtcp_unittest.cc
diff --git a/media/cast/net/rtcp/rtcp_unittest.cc b/media/cast/net/rtcp/rtcp_unittest.cc
index ef28072831afb5a6ce16f7793f8dd7fd93bcb07c..a2196f5bb088cf02061e8e36a85d29217caa39df 100644
--- a/media/cast/net/rtcp/rtcp_unittest.cc
+++ b/media/cast/net/rtcp/rtcp_unittest.cc
@@ -8,6 +8,7 @@
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/pacing/paced_sender.h"
@@ -22,6 +23,8 @@
 namespace media {
 namespace cast {
 
+class RtcpTest;
+
 namespace {
 
 media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) {
@@ -31,6 +34,21 @@ media::cast::RtcpTimeData CreateRtcpTimeData(base::TimeTicks now) {
   return ret;
 }
 
+class RtcpClient : public SenderRtcpSession::Client {
+ public:
+  explicit RtcpClient(RtcpTest* rtcp_test) : rtcp_test_(rtcp_test) {}
+
+  void OnCastMessageReceived(const RtcpCastMessage& cast_message) override;
+  void OnRttReceived(base::TimeDelta round_trip_time) override;
+  void OnReceiverLogReceived(const RtcpReceiverLogMessage& log) override;
+  void OnPliReceived() override;
+
+ private:
+  RtcpTest* const rtcp_test_;
+
+  DISALLOW_COPY_AND_ASSIGN(RtcpClient);
+};
+
 }  // namespace
 
 using testing::_;
@@ -76,38 +94,7 @@ class FakeRtcpTransport : public PacedPacketSender {
 };
 
 class RtcpTest : public ::testing::Test {
- protected:
-  RtcpTest()
-      : sender_clock_(new base::SimpleTestTickClock()),
-        receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
-        rtp_sender_pacer_(sender_clock_.get()),
-        rtp_receiver_pacer_(sender_clock_.get()),
-        rtcp_at_rtp_sender_(
-            base::Bind(&RtcpTest::OnReceivedCastFeedback,
-                       base::Unretained(this)),
-            base::Bind(&RtcpTest::OnMeasuredRoundTripTime,
-                       base::Unretained(this)),
-            base::Bind(&RtcpTest::OnReceivedLogs, base::Unretained(this)),
-            base::Bind(&RtcpTest::OnReceivedPli, base::Unretained(this)),
-            sender_clock_.get(),
-            &rtp_sender_pacer_,
-            kSenderSsrc,
-            kReceiverSsrc),
-        rtcp_at_rtp_receiver_(receiver_clock_.get(),
-                              kReceiverSsrc,
-                              kSenderSsrc),
-        received_pli_(false) {
-    sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
-    receiver_clock_->SetSkew(
-        1.0,  // No skew.
-        base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds));
-
-    rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_);
-    rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_);
-  }
-
-  ~RtcpTest() override {}
-
+ public:
   void OnReceivedCastFeedback(const RtcpCastMessage& cast_message) {
     last_cast_message_ = cast_message;
   }
@@ -135,6 +122,34 @@ class RtcpTest : public ::testing::Test {
     }
   }
 
+  void OnReceivedPli() { received_pli_ = true; }
+
+ protected:
+  RtcpTest()
+      : sender_clock_(new base::SimpleTestTickClock()),
+        receiver_clock_(new test::SkewedTickClock(sender_clock_.get())),
+        rtp_sender_pacer_(sender_clock_.get()),
+        rtp_receiver_pacer_(sender_clock_.get()),
+        rtcp_at_rtp_sender_(base::WrapUnique(new RtcpClient(this)),
+                            sender_clock_.get(),
+                            &rtp_sender_pacer_,
+                            kSenderSsrc,
+                            kReceiverSsrc),
+        rtcp_at_rtp_receiver_(receiver_clock_.get(),
+                              kReceiverSsrc,
+                              kSenderSsrc),
+        received_pli_(false) {
+    sender_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
+    receiver_clock_->SetSkew(
+        1.0,  // No skew.
+        base::TimeDelta::FromSeconds(kInitialReceiverClockOffsetSeconds));
+
+    rtp_sender_pacer_.set_rtcp_destination(&rtcp_at_rtp_receiver_);
+    rtp_receiver_pacer_.set_rtcp_destination(&rtcp_at_rtp_sender_);
+  }
+
+  ~RtcpTest() override {}
+
   PacketRef BuildRtcpPacketFromRtpReceiver(
       const RtcpTimeData& time_data,
       const RtcpCastMessage* cast_message,
@@ -182,10 +197,8 @@ class RtcpTest : public ::testing::Test {
     return builder.Finish();
   }
 
-  void OnReceivedPli() { received_pli_ = true; }
-
-  scoped_ptr<base::SimpleTestTickClock> sender_clock_;
-  scoped_ptr<test::SkewedTickClock> receiver_clock_;
+  std::unique_ptr<base::SimpleTestTickClock> sender_clock_;
+  std::unique_ptr<test::SkewedTickClock> receiver_clock_;
   FakeRtcpTransport rtp_sender_pacer_;
   FakeRtcpTransport rtp_receiver_pacer_;
   SenderRtcpSession rtcp_at_rtp_sender_;
@@ -200,6 +213,26 @@ class RtcpTest : public ::testing::Test {
   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 };
 
+namespace {
+
+void RtcpClient::OnCastMessageReceived(const RtcpCastMessage& cast_message) {
+  rtcp_test_->OnReceivedCastFeedback(cast_message);
+}
+
+void RtcpClient::OnRttReceived(base::TimeDelta round_trip_time) {
+  rtcp_test_->OnMeasuredRoundTripTime(round_trip_time);
+}
+
+void RtcpClient::OnReceiverLogReceived(const RtcpReceiverLogMessage& log) {
+  rtcp_test_->OnReceivedLogs(log);
+}
+
+void RtcpClient::OnPliReceived() {
+  rtcp_test_->OnReceivedPli();
+}
+
+}  // namespace
+
 TEST_F(RtcpTest, LipSyncGleanedFromSenderReport) {
   // Initially, expect no lip-sync info receiver-side without having first
   // received a RTCP packet.