Convert //media/cast from scoped_ptr to std::unique_ptr

media/cast/logging/stats_event_subscriber_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 "media/cast/logging/stats_event_subscriber.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/values.h"
 #include "media/base/fake_single_thread_task_runner.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/logging/logging_defines.h"
 #include "media/cast/test/fake_receiver_time_offset_estimator.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 const int kReceiverOffsetSecs = 100;
 }
 
 namespace media {
 namespace cast {
 
 class StatsEventSubscriberTest : public ::testing::Test {
  protected:
   StatsEventSubscriberTest()
       : sender_clock_(new base::SimpleTestTickClock()),
         task_runner_(new FakeSingleThreadTaskRunner(sender_clock_)),
         cast_environment_(
-            new CastEnvironment(scoped_ptr<base::TickClock>(sender_clock_),
+            new CastEnvironment(std::unique_ptr<base::TickClock>(sender_clock_),
                                 task_runner_,
                                 task_runner_,
                                 task_runner_)),
         fake_offset_estimator_(
             base::TimeDelta::FromSeconds(kReceiverOffsetSecs)) {
     receiver_clock_.Advance(base::TimeDelta::FromSeconds(kReceiverOffsetSecs));
     cast_environment_->logger()->Subscribe(&fake_offset_estimator_);
   }
 
   ~StatsEventSubscriberTest() override {
@@ skipping 12 matching lines @@
     subscriber_.reset(new StatsEventSubscriber(
         event_media_type, cast_environment_->Clock(), &fake_offset_estimator_));
     cast_environment_->logger()->Subscribe(subscriber_.get());
   }
 
   base::SimpleTestTickClock* sender_clock_;  // Owned by CastEnvironment.
   base::SimpleTestTickClock receiver_clock_;
   scoped_refptr<FakeSingleThreadTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_;
   test::FakeReceiverTimeOffsetEstimator fake_offset_estimator_;
-  scoped_ptr<StatsEventSubscriber> subscriber_;
+  std::unique_ptr<StatsEventSubscriber> subscriber_;
 };
 
 TEST_F(StatsEventSubscriberTest, CaptureEncode) {
   Init(VIDEO_EVENT);
 
   RtpTimeTicks rtp_timestamp;
   uint32_t frame_id = 0;
   int extra_frames = 50;
   // Only the first |extra_frames| frames logged will be taken into account
   // when computing dropped frames.
   int num_frames = StatsEventSubscriber::kMaxFrameInfoMapSize + 50;
   int dropped_frames = 0;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   // Drop half the frames during the encode step.
   for (int i = 0; i < num_frames; i++) {
-    scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> capture_begin_event(new FrameEvent());
     capture_begin_event->timestamp = sender_clock_->NowTicks();
     capture_begin_event->type = FRAME_CAPTURE_BEGIN;
     capture_begin_event->media_type = VIDEO_EVENT;
     capture_begin_event->rtp_timestamp = rtp_timestamp;
     cast_environment_->logger()->DispatchFrameEvent(
         std::move(capture_begin_event));
 
     AdvanceClocks(base::TimeDelta::FromMicroseconds(10));
-    scoped_ptr<FrameEvent> capture_end_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> capture_end_event(new FrameEvent());
     capture_end_event->timestamp = sender_clock_->NowTicks();
     capture_end_event->type = FRAME_CAPTURE_END;
     capture_end_event->media_type = VIDEO_EVENT;
     capture_end_event->rtp_timestamp = rtp_timestamp;
     cast_environment_->logger()->DispatchFrameEvent(
         std::move(capture_end_event));
 
     if (i % 2 == 0) {
       AdvanceClocks(base::TimeDelta::FromMicroseconds(10));
-      scoped_ptr<FrameEvent> encode_event(new FrameEvent());
+      std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
       encode_event->timestamp = sender_clock_->NowTicks();
       encode_event->type = FRAME_ENCODED;
       encode_event->media_type = VIDEO_EVENT;
       encode_event->rtp_timestamp = rtp_timestamp;
       encode_event->frame_id = frame_id;
       encode_event->size = 1024;
       encode_event->key_frame = true;
       encode_event->target_bitrate = 5678;
       encode_event->encoder_cpu_utilization = 9.10;
       encode_event->idealized_bitrate_utilization = 11.12;
@@ skipping 43 matching lines @@
   uint32_t frame_id = 0;
   int num_frames = 10;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   AdvanceClocks(base::TimeDelta::FromMicroseconds(35678));
   base::TimeTicks first_event_time = sender_clock_->NowTicks();
   base::TimeTicks last_event_time;
   int total_size = 0;
   for (int i = 0; i < num_frames; i++) {
     int size = 1000 + base::RandInt(-100, 100);
     total_size += size;
-    scoped_ptr<FrameEvent> encode_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
     encode_event->timestamp = sender_clock_->NowTicks();
     encode_event->type = FRAME_ENCODED;
     encode_event->media_type = VIDEO_EVENT;
     encode_event->rtp_timestamp = rtp_timestamp;
     encode_event->frame_id = frame_id;
     encode_event->size = size;
     encode_event->key_frame = true;
     encode_event->target_bitrate = 5678;
     encode_event->encoder_cpu_utilization = 9.10;
     encode_event->idealized_bitrate_utilization = 11.12;
@@ skipping 41 matching lines @@
 }
 
 TEST_F(StatsEventSubscriberTest, Decode) {
   Init(VIDEO_EVENT);
 
   RtpTimeTicks rtp_timestamp;
   uint32_t frame_id = 0;
   int num_frames = 10;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   for (int i = 0; i < num_frames; i++) {
-    scoped_ptr<FrameEvent> decode_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> decode_event(new FrameEvent());
     decode_event->timestamp = receiver_clock_.NowTicks();
     decode_event->type = FRAME_DECODED;
     decode_event->media_type = VIDEO_EVENT;
     decode_event->rtp_timestamp = rtp_timestamp;
     decode_event->frame_id = frame_id;
     cast_environment_->logger()->DispatchFrameEvent(std::move(decode_event));
 
     AdvanceClocks(base::TimeDelta::FromMicroseconds(36789));
     rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
@@ skipping 18 matching lines @@
   Init(VIDEO_EVENT);
 
   RtpTimeTicks rtp_timestamp;
   uint32_t frame_id = 0;
   int num_frames = 10;
   int late_frames = 0;
   for (int i = 0, delay_ms = -50; i < num_frames; i++, delay_ms += 10) {
     base::TimeDelta delay = base::TimeDelta::FromMilliseconds(delay_ms);
     if (delay_ms > 0)
       late_frames++;
-    scoped_ptr<FrameEvent> playout_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> playout_event(new FrameEvent());
     playout_event->timestamp = receiver_clock_.NowTicks();
     playout_event->type = FRAME_PLAYOUT;
     playout_event->media_type = VIDEO_EVENT;
     playout_event->rtp_timestamp = rtp_timestamp;
     playout_event->frame_id = frame_id;
     playout_event->delay_delta = delay;
     cast_environment_->logger()->DispatchFrameEvent(std::move(playout_event));
 
     AdvanceClocks(base::TimeDelta::FromMicroseconds(37890));
     rtp_timestamp += RtpTimeDelta::FromTicks(90);
@@ skipping 11 matching lines @@
 }
 
 TEST_F(StatsEventSubscriberTest, E2ELatency) {
   Init(VIDEO_EVENT);
 
   RtpTimeTicks rtp_timestamp;
   uint32_t frame_id = 0;
   int num_frames = 10;
   base::TimeDelta total_latency;
   for (int i = 0; i < num_frames; i++) {
-    scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> capture_begin_event(new FrameEvent());
     capture_begin_event->timestamp = sender_clock_->NowTicks();
     capture_begin_event->type = FRAME_CAPTURE_BEGIN;
     capture_begin_event->media_type = VIDEO_EVENT;
     capture_begin_event->rtp_timestamp = rtp_timestamp;
     cast_environment_->logger()->DispatchFrameEvent(
         std::move(capture_begin_event));
 
     int latency_micros = 100000 + base::RandInt(-5000, 50000);
     base::TimeDelta latency = base::TimeDelta::FromMicroseconds(latency_micros);
     AdvanceClocks(latency);
 
     int delay_micros = base::RandInt(-50000, 50000);
     base::TimeDelta delay = base::TimeDelta::FromMilliseconds(delay_micros);
     total_latency += latency;
 
-    scoped_ptr<FrameEvent> playout_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> playout_event(new FrameEvent());
     playout_event->timestamp = receiver_clock_.NowTicks();
     playout_event->type = FRAME_PLAYOUT;
     playout_event->media_type = VIDEO_EVENT;
     playout_event->rtp_timestamp = rtp_timestamp;
     playout_event->frame_id = frame_id;
     playout_event->delay_delta = delay;
     cast_environment_->logger()->DispatchFrameEvent(std::move(playout_event));
 
     rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
@@ skipping 22 matching lines @@
   base::TimeDelta total_network_latency;
   base::TimeDelta total_queueing_latency;
   base::TimeDelta total_packet_latency;
   int num_packets_transmitted = 0;
   int num_packets_received = 0;
   int num_packets_retransmitted = 0;
   int num_packets_rtx_rejected = 0;
 
   base::TimeTicks sender_encoded_time = sender_clock_->NowTicks();
   base::TimeTicks receiver_encoded_time = receiver_clock_.NowTicks();
-  scoped_ptr<FrameEvent> encode_event(new FrameEvent());
+  std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
   encode_event->timestamp = sender_encoded_time;
   encode_event->type = FRAME_ENCODED;
   encode_event->media_type = VIDEO_EVENT;
   encode_event->rtp_timestamp = rtp_timestamp;
   encode_event->frame_id = 0;
   cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
 
   // Every 2nd packet will be retransmitted once.
   // Every 4th packet will be retransmitted twice.
   // Every 8th packet will be retransmitted 3 times + 1 rejected retransmission.
   for (int i = 0; i < num_packets; i++) {
     int size = 1000 + base::RandInt(-100, 100);
     total_size += size;
 
-    scoped_ptr<PacketEvent> send_event(new PacketEvent());
+    std::unique_ptr<PacketEvent> send_event(new PacketEvent());
     send_event->timestamp = sender_clock_->NowTicks();
     send_event->type = PACKET_SENT_TO_NETWORK;
     send_event->media_type = VIDEO_EVENT;
     send_event->rtp_timestamp = rtp_timestamp;
     send_event->frame_id = 0;
     send_event->packet_id = i;
     send_event->max_packet_id = num_packets - 1;
     send_event->size = size;
     cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
 
@@ skipping 10 matching lines @@
       num_latency_recorded_packets++;
     }
 
     AdvanceClocks(latency);
 
     base::TimeTicks received_time = receiver_clock_.NowTicks();
 
     // Retransmission 1.
     AdvanceClocks(base::TimeDelta::FromMicroseconds(12345));
     if (i % 2 == 0) {
-      scoped_ptr<PacketEvent> retransmit_event(new PacketEvent());
+      std::unique_ptr<PacketEvent> retransmit_event(new PacketEvent());
       retransmit_event->timestamp = receiver_clock_.NowTicks();
       retransmit_event->type = PACKET_RETRANSMITTED;
       retransmit_event->media_type = VIDEO_EVENT;
       retransmit_event->rtp_timestamp = rtp_timestamp;
       retransmit_event->frame_id = 0;
       retransmit_event->packet_id = i;
       retransmit_event->max_packet_id = num_packets - 1;
       retransmit_event->size = size;
       cast_environment_->logger()->DispatchPacketEvent(
           std::move(retransmit_event));
 
       retransmit_total_size += size;
       num_packets_transmitted++;
       num_packets_retransmitted++;
     }
 
     // Retransmission 2.
     AdvanceClocks(base::TimeDelta::FromMicroseconds(13456));
     if (i % 4 == 0) {
-      scoped_ptr<PacketEvent> retransmit_event(new PacketEvent());
+      std::unique_ptr<PacketEvent> retransmit_event(new PacketEvent());
       retransmit_event->timestamp = receiver_clock_.NowTicks();
       retransmit_event->type = PACKET_RETRANSMITTED;
       retransmit_event->media_type = VIDEO_EVENT;
       retransmit_event->rtp_timestamp = rtp_timestamp;
       retransmit_event->frame_id = 0;
       retransmit_event->packet_id = i;
       retransmit_event->max_packet_id = num_packets - 1;
       retransmit_event->size = size;
       cast_environment_->logger()->DispatchPacketEvent(
           std::move(retransmit_event));
 
       retransmit_total_size += size;
       num_packets_transmitted++;
       num_packets_retransmitted++;
     }
 
     // Retransmission 3.
     AdvanceClocks(base::TimeDelta::FromMicroseconds(14567));
     if (i % 8 == 0) {
-      scoped_ptr<PacketEvent> retransmit_event(new PacketEvent());
+      std::unique_ptr<PacketEvent> retransmit_event(new PacketEvent());
       retransmit_event->timestamp = receiver_clock_.NowTicks();
       retransmit_event->type = PACKET_RETRANSMITTED;
       retransmit_event->media_type = VIDEO_EVENT;
       retransmit_event->rtp_timestamp = rtp_timestamp;
       retransmit_event->frame_id = 0;
       retransmit_event->packet_id = i;
       retransmit_event->max_packet_id = num_packets - 1;
       retransmit_event->size = size;
       cast_environment_->logger()->DispatchPacketEvent(
           std::move(retransmit_event));
 
-      scoped_ptr<PacketEvent> reject_event(new PacketEvent());
+      std::unique_ptr<PacketEvent> reject_event(new PacketEvent());
       reject_event->timestamp = receiver_clock_.NowTicks();
       reject_event->type = PACKET_RTX_REJECTED;
       reject_event->media_type = VIDEO_EVENT;
       reject_event->rtp_timestamp = rtp_timestamp;
       reject_event->frame_id = 0;
       reject_event->packet_id = i;
       reject_event->max_packet_id = num_packets - 1;
       reject_event->size = size;
       cast_environment_->logger()->DispatchPacketEvent(std::move(reject_event));
 
       retransmit_total_size += size;
       num_packets_transmitted++;
       num_packets_retransmitted++;
       num_packets_rtx_rejected++;
     }
 
-    scoped_ptr<PacketEvent> receive_event(new PacketEvent());
+    std::unique_ptr<PacketEvent> receive_event(new PacketEvent());
     receive_event->timestamp = received_time;
     receive_event->type = PACKET_RECEIVED;
     receive_event->media_type = VIDEO_EVENT;
     receive_event->rtp_timestamp = rtp_timestamp;
     receive_event->frame_id = 0;
     receive_event->packet_id = i;
     receive_event->max_packet_id = num_packets - 1;
     receive_event->size = size;
     cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
 
@@ skipping 84 matching lines @@
 
   RtpTimeTicks rtp_timestamp = RtpTimeTicks().Expand(UINT32_C(123));
   uint32_t frame_id = 0;
 
   // 10 Frames with capture latency in the bucket of "10-14"ms.
   // 10 Frames with encode time in the bucket of "15-19"ms.
   for (int i = 0; i < 10; ++i) {
     ++frame_id;
     rtp_timestamp += RtpTimeDelta::FromTicks(1);
 
-    scoped_ptr<FrameEvent> capture_begin_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> capture_begin_event(new FrameEvent());
     capture_begin_event->timestamp = sender_clock_->NowTicks();
     capture_begin_event->type = FRAME_CAPTURE_BEGIN;
     capture_begin_event->media_type = VIDEO_EVENT;
     capture_begin_event->rtp_timestamp = rtp_timestamp;
     cast_environment_->logger()->DispatchFrameEvent(
         std::move(capture_begin_event));
 
     AdvanceClocks(base::TimeDelta::FromMilliseconds(10));
-    scoped_ptr<FrameEvent> capture_end_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> capture_end_event(new FrameEvent());
     capture_end_event->timestamp = sender_clock_->NowTicks();
     capture_end_event->type = FRAME_CAPTURE_END;
     capture_end_event->media_type = VIDEO_EVENT;
     capture_end_event->rtp_timestamp = rtp_timestamp;
     cast_environment_->logger()->DispatchFrameEvent(
         std::move(capture_end_event));
 
     AdvanceClocks(base::TimeDelta::FromMilliseconds(15));
-    scoped_ptr<FrameEvent> encode_event(new FrameEvent());
+    std::unique_ptr<FrameEvent> encode_event(new FrameEvent());
     encode_event->timestamp = sender_clock_->NowTicks();
     encode_event->type = FRAME_ENCODED;
     encode_event->media_type = VIDEO_EVENT;
     encode_event->rtp_timestamp = rtp_timestamp;
     encode_event->frame_id = frame_id;
     encode_event->size = 1024;
     encode_event->key_frame = true;
     encode_event->target_bitrate = 5678;
     encode_event->encoder_cpu_utilization = 9.10;
     encode_event->idealized_bitrate_utilization = 11.12;
     cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
   }
 
   // Send 3 packets for the last frame.
   // Queueing latencies are 100ms, 200ms and 300ms.
   for (int i = 0; i < 3; ++i) {
     AdvanceClocks(base::TimeDelta::FromMilliseconds(100));
-    scoped_ptr<PacketEvent> send_event(new PacketEvent());
+    std::unique_ptr<PacketEvent> send_event(new PacketEvent());
     send_event->timestamp = sender_clock_->NowTicks();
     send_event->type = PACKET_SENT_TO_NETWORK;
     send_event->media_type = VIDEO_EVENT;
     send_event->rtp_timestamp = rtp_timestamp;
     send_event->frame_id = 0;
     send_event->packet_id = i;
     send_event->max_packet_id = 2;
     send_event->size = 123;
     cast_environment_->logger()->DispatchPacketEvent(std::move(send_event));
   }
 
   // Receive 3 packets for the last frame.
   // Network latencies are 100ms, 200ms and 300ms.
   // Packet latencies are 400ms.
   AdvanceClocks(base::TimeDelta::FromMilliseconds(100));
   for (int i = 0; i < 3; ++i) {
-    scoped_ptr<PacketEvent> receive_event(new PacketEvent());
+    std::unique_ptr<PacketEvent> receive_event(new PacketEvent());
     receive_event->timestamp = receiver_clock_.NowTicks();
     receive_event->type = PACKET_RECEIVED;
     receive_event->media_type = VIDEO_EVENT;
     receive_event->rtp_timestamp = rtp_timestamp;
     receive_event->frame_id = 0;
     receive_event->packet_id = i;
     receive_event->max_packet_id = 2;
     receive_event->size = 123;
     cast_environment_->logger()->DispatchPacketEvent(std::move(receive_event));
   }
 
-  scoped_ptr<FrameEvent> playout_event(new FrameEvent());
+  std::unique_ptr<FrameEvent> playout_event(new FrameEvent());
   playout_event->timestamp = receiver_clock_.NowTicks();
   playout_event->type = FRAME_PLAYOUT;
   playout_event->media_type = VIDEO_EVENT;
   playout_event->rtp_timestamp = rtp_timestamp;
   playout_event->frame_id = frame_id;
   playout_event->delay_delta = base::TimeDelta::FromMilliseconds(100);
   cast_environment_->logger()->DispatchFrameEvent(std::move(playout_event));
 
   StatsEventSubscriber::SimpleHistogram* histogram;
-  scoped_ptr<base::ListValue> values;
+  std::unique_ptr<base::ListValue> values;
 
   histogram = subscriber_->GetHistogramForTesting(
       StatsEventSubscriber::CAPTURE_LATENCY_MS_HISTO);
   ASSERT_TRUE(histogram);
   values = histogram->GetHistogram();
   EXPECT_TRUE(CheckHistogramHasValue(values.get(), "10-14", 10));
 
   histogram = subscriber_->GetHistogramForTesting(
       StatsEventSubscriber::ENCODE_TIME_MS_HISTO);
   ASSERT_TRUE(histogram);
@@ skipping 24 matching lines @@
 
   histogram = subscriber_->GetHistogramForTesting(
       StatsEventSubscriber::LATE_FRAME_MS_HISTO);
   ASSERT_TRUE(histogram);
   values = histogram->GetHistogram();
   EXPECT_TRUE(CheckHistogramHasValue(values.get(), "100-119", 1));
 }
 
 }  // namespace cast
 }  // namespace media