Replace uses of raw uint32's with a type-checked RtpTimeTicks data type.

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 <utility>
 
@@ skipping 54 matching lines @@
   base::SimpleTestTickClock receiver_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   scoped_refptr<CastEnvironment> cast_environment_;
   test::FakeReceiverTimeOffsetEstimator fake_offset_estimator_;
   scoped_ptr<StatsEventSubscriber> subscriber_;
 };
 
 TEST_F(StatsEventSubscriberTest, CaptureEncode) {
   Init(VIDEO_EVENT);
 
-  uint32_t rtp_timestamp = 0;
+  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());
@@ skipping 24 matching lines @@
       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));
     } else if (i < extra_frames) {
       dropped_frames++;
     }
     AdvanceClocks(base::TimeDelta::FromMicroseconds(34567));
-    rtp_timestamp += 90;
+    rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
   }
 
   base::TimeTicks end_time = sender_clock_->NowTicks();
 
   StatsEventSubscriber::StatsMap stats_map;
   subscriber_->GetStatsInternal(&stats_map);
 
   StatsEventSubscriber::StatsMap::iterator it =
       stats_map.find(StatsEventSubscriber::CAPTURE_FPS);
@@ skipping 16 matching lines @@
 
   it = stats_map.find(StatsEventSubscriber::AVG_CAPTURE_LATENCY_MS);
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(it->second, static_cast<double>(0.01));
 }
 
 TEST_F(StatsEventSubscriberTest, Encode) {
   Init(VIDEO_EVENT);
 
-  uint32_t rtp_timestamp = 0;
+  RtpTimeTicks rtp_timestamp;
   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());
     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;
     cast_environment_->logger()->DispatchFrameEvent(std::move(encode_event));
     last_event_time = sender_clock_->NowTicks();
 
     AdvanceClocks(base::TimeDelta::FromMicroseconds(35678));
-    rtp_timestamp += 90;
+    rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
   }
 
   base::TimeTicks end_time = sender_clock_->NowTicks();
 
   StatsEventSubscriber::StatsMap stats_map;
   subscriber_->GetStatsInternal(&stats_map);
 
   StatsEventSubscriber::StatsMap::iterator it =
       stats_map.find(StatsEventSubscriber::ENCODE_FPS);
@@ skipping 21 matching lines @@
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(
       it->second,
       (last_event_time - base::TimeTicks::UnixEpoch()).InMillisecondsF());
 }
 
 TEST_F(StatsEventSubscriberTest, Decode) {
   Init(VIDEO_EVENT);
 
-  uint32_t rtp_timestamp = 0;
+  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());
     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 += 90;
+    rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
   }
 
   base::TimeTicks end_time = sender_clock_->NowTicks();
 
   StatsEventSubscriber::StatsMap stats_map;
   subscriber_->GetStatsInternal(&stats_map);
 
   StatsEventSubscriber::StatsMap::iterator it =
       stats_map.find(StatsEventSubscriber::DECODE_FPS);
   ASSERT_TRUE(it != stats_map.end());
 
   base::TimeDelta duration = end_time - start_time;
   EXPECT_DOUBLE_EQ(
       it->second,
       static_cast<double>(num_frames) / duration.InMillisecondsF() * 1000);
 }
 
 TEST_F(StatsEventSubscriberTest, PlayoutDelay) {
   Init(VIDEO_EVENT);
 
-  uint32_t rtp_timestamp = 0;
+  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());
     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 += 90;
+    rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
   }
 
   StatsEventSubscriber::StatsMap stats_map;
   subscriber_->GetStatsInternal(&stats_map);
 
   StatsEventSubscriber::StatsMap::iterator it = stats_map.find(
       StatsEventSubscriber::NUM_FRAMES_LATE);
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(it->second, late_frames);
 }
 
 TEST_F(StatsEventSubscriberTest, E2ELatency) {
   Init(VIDEO_EVENT);
 
-  uint32_t rtp_timestamp = 0;
+  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());
     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());
     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 += 90;
+    rtp_timestamp += RtpTimeDelta::FromTicks(90);
     frame_id++;
   }
 
   StatsEventSubscriber::StatsMap stats_map;
   subscriber_->GetStatsInternal(&stats_map);
 
   StatsEventSubscriber::StatsMap::iterator it =
       stats_map.find(StatsEventSubscriber::AVG_E2E_LATENCY_MS);
   ASSERT_TRUE(it != stats_map.end());
 
   EXPECT_DOUBLE_EQ(
       it->second, total_latency.InMillisecondsF() / num_frames);
 }
 
 TEST_F(StatsEventSubscriberTest, Packets) {
   Init(VIDEO_EVENT);
 
-  uint32_t rtp_timestamp = 0;
+  RtpTimeTicks rtp_timestamp;
   int num_packets = 10;
   int num_latency_recorded_packets = 0;
   base::TimeTicks start_time = sender_clock_->NowTicks();
   int total_size = 0;
   int retransmit_total_size = 0;
   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;
@@ skipping 206 matching lines @@
       return false;
     return bucket_count == expected_count;
   }
   return false;
 }
 
 TEST_F(StatsEventSubscriberTest, Histograms) {
   Init(VIDEO_EVENT);
   AdvanceClocks(base::TimeDelta::FromMilliseconds(123));
 
-  uint32_t rtp_timestamp = 123;
+  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;
+    rtp_timestamp += RtpTimeDelta::FromTicks(1);
 
     scoped_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));
@@ skipping 101 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