Cast: Fix memory leak in cast_unittests

media/cast/net/rtcp/rtcp_unittest.cc

 // Copyright 2014 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 <stdint.h>
 
 #include "base/test/simple_test_tick_clock.h"
 #include "media/cast/cast_defines.h"
 #include "media/cast/net/cast_transport_config.h"
 #include "media/cast/net/cast_transport_sender_impl.h"
@@ skipping 41 matching lines @@
       return true;
 
     rtcp_receiver_->IncomingRtcpPacket(&packet->data[0], packet->data.size());
     return true;
   }
 
  private:
   bool drop_packets_;
   bool short_delay_;
   Rtcp* rtcp_receiver_;
-  base::SimpleTestTickClock* testing_clock_;
+  base::SimpleTestTickClock* testing_clock_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(RtcpTestPacketSender);
 };
 
 class LocalRtcpTransport : public PacedPacketSender {
  public:
   explicit LocalRtcpTransport(base::SimpleTestTickClock* testing_clock)
       : drop_packets_(false),
         short_delay_(false),
         testing_clock_(testing_clock) {}
@@ skipping 30 matching lines @@
   }
 
   virtual void CancelSendingPacket(
       const PacketKey& packet_key) OVERRIDE {
   }
 
  private:
   bool drop_packets_;
   bool short_delay_;
   Rtcp* rtcp_;
-  base::SimpleTestTickClock* testing_clock_;
+  base::SimpleTestTickClock* testing_clock_;  // Not owned.
 
   DISALLOW_COPY_AND_ASSIGN(LocalRtcpTransport);
 };
 
 class MockReceiverStats : public RtpReceiverStatistics {
  public:
   MockReceiverStats() {}
   virtual ~MockReceiverStats() {}
 
   virtual void GetStatistics(uint8* fraction_lost,
@@ skipping 23 matching lines @@
                     base::TimeDelta min_rtt,
                     base::TimeDelta max_rtt));
  private:
   DISALLOW_COPY_AND_ASSIGN(MockFrameSender);
 };
 
 class RtcpTest : public ::testing::Test {
  protected:
   RtcpTest()
       : testing_clock_(new base::SimpleTestTickClock()),
-        task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
-        sender_to_receiver_(testing_clock_),
-        receiver_to_sender_(testing_clock_) {
+        task_runner_(
+            new test::FakeSingleThreadTaskRunner(testing_clock_.get())),
+        sender_to_receiver_(testing_clock_.get()),
+        receiver_to_sender_(testing_clock_.get()) {
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
   }
 
   virtual ~RtcpTest() {}
 
   static void UpdateCastTransportStatus(CastTransportStatus status) {
     bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
                    status == TRANSPORT_VIDEO_INITIALIZED);
     EXPECT_TRUE(result);
   }
 
   void RunTasks(int during_ms) {
     for (int i = 0; i < during_ms; ++i) {
       // Call process the timers every 1 ms.
       testing_clock_->Advance(base::TimeDelta::FromMilliseconds(1));
       task_runner_->RunTasks();
     }
   }
 
-  base::SimpleTestTickClock* testing_clock_;  // Owned by CastEnvironment.
+  scoped_ptr<base::SimpleTestTickClock> testing_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   LocalRtcpTransport sender_to_receiver_;
   LocalRtcpTransport receiver_to_sender_;
   MockFrameSender mock_frame_sender_;
   MockReceiverStats stats_;
 
   DISALLOW_COPY_AND_ASSIGN(RtcpTest);
 };
 
 TEST_F(RtcpTest, BasicSenderReport) {
   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                        base::Unretained(&mock_frame_sender_)),
             base::Bind(&MockFrameSender::OnReceivedRtt,
                        base::Unretained(&mock_frame_sender_)),
             RtcpLogMessageCallback(),
-            testing_clock_,
+            testing_clock_.get(),
             &sender_to_receiver_,
             kSenderSsrc,
             kReceiverSsrc);
   sender_to_receiver_.set_rtcp_receiver(&rtcp);
   rtcp.SendRtcpFromRtpSender(base::TimeTicks(), 0, 1, 1);
 }
 
 TEST_F(RtcpTest, BasicReceiverReport) {
   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                        base::Unretained(&mock_frame_sender_)),
             base::Bind(&MockFrameSender::OnReceivedRtt,
                        base::Unretained(&mock_frame_sender_)),
             RtcpLogMessageCallback(),
-            testing_clock_,
+            testing_clock_.get(),
             &receiver_to_sender_,
             kSenderSsrc,
             kReceiverSsrc);
   receiver_to_sender_.set_rtcp_receiver(&rtcp);
   rtcp.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
 }
 
 TEST_F(RtcpTest, BasicCast) {
   EXPECT_CALL(mock_frame_sender_, OnReceivedCastFeedback(_)).Times(1);
 
   // Media sender.
   Rtcp rtcp(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                        base::Unretained(&mock_frame_sender_)),
             base::Bind(&MockFrameSender::OnReceivedRtt,
                        base::Unretained(&mock_frame_sender_)),
             RtcpLogMessageCallback(),
-            testing_clock_,
+            testing_clock_.get(),
             &receiver_to_sender_,
             kSenderSsrc,
             kSenderSsrc);
   receiver_to_sender_.set_rtcp_receiver(&rtcp);
   RtcpCastMessage cast_message(kSenderSsrc);
   cast_message.ack_frame_id = kAckFrameId;
   PacketIdSet missing_packets;
   cast_message.missing_frames_and_packets[kLostFrameId] = missing_packets;
 
   missing_packets.insert(kLostPacketId1);
   missing_packets.insert(kLostPacketId2);
   missing_packets.insert(kLostPacketId3);
   cast_message.missing_frames_and_packets[kFrameIdWithLostPackets] =
       missing_packets;
   rtcp.SendRtcpFromRtpReceiver(&cast_message, base::TimeDelta(), NULL, NULL);
 }
 
 TEST_F(RtcpTest, RttReducedSizeRtcp) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
-                     testing_clock_,
+                     testing_clock_.get(),
                      &receiver_to_sender_,
                      kReceiverSsrc,
                      kSenderSsrc);
 
   // Media sender.
   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                               base::Unretained(&mock_frame_sender_)),
                    base::Bind(&MockFrameSender::OnReceivedRtt,
                               base::Unretained(&mock_frame_sender_)),
                    RtcpLogMessageCallback(),
-                   testing_clock_,
+                   testing_clock_.get(),
                    &sender_to_receiver_,
                    kSenderSsrc,
                    kReceiverSsrc);
 
   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
   base::TimeDelta min_rtt;
@@ skipping 18 matching lines @@
   EXPECT_NEAR(2 * kAddedDelay, avg_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, min_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 }
 
 TEST_F(RtcpTest, Rtt) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
-                     testing_clock_,
+                     testing_clock_.get(),
                      &receiver_to_sender_,
                      kReceiverSsrc,
                      kSenderSsrc);
 
   // Media sender.
   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                               base::Unretained(&mock_frame_sender_)),
                    base::Bind(&MockFrameSender::OnReceivedRtt,
                               base::Unretained(&mock_frame_sender_)),
                    RtcpLogMessageCallback(),
-                   testing_clock_,
+                   testing_clock_.get(),
                    &sender_to_receiver_,
                    kSenderSsrc,
                    kReceiverSsrc);
 
   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 
   base::TimeDelta rtt;
   base::TimeDelta avg_rtt;
   base::TimeDelta min_rtt;
@@ skipping 55 matching lines @@
   EXPECT_NEAR(2 * kAddedShortDelay, rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedShortDelay, min_rtt.InMilliseconds(), 2);
   EXPECT_NEAR(2 * kAddedDelay, max_rtt.InMilliseconds(), 2);
 }
 
 TEST_F(RtcpTest, RttWithPacketLoss) {
   // Media receiver.
   Rtcp rtcp_receiver(RtcpCastMessageCallback(),
                      RtcpRttCallback(),
                      RtcpLogMessageCallback(),
-                     testing_clock_,
+                     testing_clock_.get(),
                      &receiver_to_sender_,
                      kReceiverSsrc,
                      kSenderSsrc);
 
   // Media sender.
   Rtcp rtcp_sender(base::Bind(&MockFrameSender::OnReceivedCastFeedback,
                               base::Unretained(&mock_frame_sender_)),
                    base::Bind(&MockFrameSender::OnReceivedRtt,
                               base::Unretained(&mock_frame_sender_)),
                    RtcpLogMessageCallback(),
-                   testing_clock_,
+                   testing_clock_.get(),
                    &sender_to_receiver_,
                    kSenderSsrc,
                    kReceiverSsrc);
 
   receiver_to_sender_.set_rtcp_receiver(&rtcp_sender);
   sender_to_receiver_.set_rtcp_receiver(&rtcp_receiver);
 
   rtcp_receiver.SendRtcpFromRtpReceiver(NULL, base::TimeDelta(), NULL, &stats_);
   rtcp_sender.SendRtcpFromRtpSender(testing_clock_->NowTicks(), 0, 1, 1);
   RunTasks(33);
@@ skipping 62 matching lines @@
   base::TimeTicks out_3 = ConvertNtpToTimeTicks(ntp_seconds_3, ntp_fraction_3);
   EXPECT_EQ(input_time, out_3);  // Verify inverse.
 
   // Verify delta.
   EXPECT_EQ((out_3 - out_2), time_delta);
   EXPECT_NEAR((ntp_fraction_3 - ntp_fraction_2), 0xffffffff / 2, 1);
 }
 
 }  // namespace cast
 }  // namespace media