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

media/cast/sender/audio_encoder_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 <sstream>
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/audio_bus.h"
 #include "media/base/media.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
+#include "media/cast/common/rtp_time.h"
 #include "media/cast/sender/audio_encoder.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace media {
 namespace cast {
 
 static const int kNumChannels = 2;
 
 namespace {
 
 class TestEncodedAudioFrameReceiver {
  public:
-  TestEncodedAudioFrameReceiver() : frames_received_(0), rtp_lower_bound_(0) {}
+  TestEncodedAudioFrameReceiver() : frames_received_(0) {}
   virtual ~TestEncodedAudioFrameReceiver() {}
 
   int frames_received() const { return frames_received_; }
 
   void SetCaptureTimeBounds(const base::TimeTicks& lower_bound,
                             const base::TimeTicks& upper_bound) {
     lower_bound_ = lower_bound;
     upper_bound_ = upper_bound;
   }
 
   void SetSamplesPerFrame(int samples_per_frame) {
     samples_per_frame_ = samples_per_frame;
   }
 
   void FrameEncoded(scoped_ptr<SenderEncodedFrame> encoded_frame,
                     int samples_skipped) {
     EXPECT_EQ(encoded_frame->dependency, EncodedFrame::KEY);
     EXPECT_EQ(static_cast<uint8>(frames_received_ & 0xff),
               encoded_frame->frame_id);
     EXPECT_EQ(encoded_frame->frame_id, encoded_frame->referenced_frame_id);
     // RTP timestamps should be monotonically increasing and integer multiples
     // of the fixed frame size.
     EXPECT_LE(rtp_lower_bound_, encoded_frame->rtp_timestamp);
     rtp_lower_bound_ = encoded_frame->rtp_timestamp;
-    EXPECT_EQ(0u, encoded_frame->rtp_timestamp % samples_per_frame_);
+    EXPECT_EQ(RtpTimeDelta(), (encoded_frame->rtp_timestamp - RtpTimeTicks()) %
+                                  RtpTimeDelta::FromTicks(samples_per_frame_));
     EXPECT_TRUE(!encoded_frame->data.empty());
 
     EXPECT_LE(lower_bound_, encoded_frame->reference_time);
     lower_bound_ = encoded_frame->reference_time;
     EXPECT_GT(upper_bound_, encoded_frame->reference_time);
 
     EXPECT_LE(0.0, encoded_frame->deadline_utilization);
     EXPECT_EQ(-1.0, encoded_frame->lossy_utilization);
 
     ++frames_received_;
   }
 
  private:
   int frames_received_;
-  uint32 rtp_lower_bound_;
+  RtpTimeTicks rtp_lower_bound_;
   int samples_per_frame_;
   base::TimeTicks lower_bound_;
   base::TimeTicks upper_bound_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEncodedAudioFrameReceiver);
 };
 
 struct TestScenario {
   const int64* durations_in_ms;
   size_t num_durations;
@@ skipping 162 matching lines @@
         TestScenario(kManyCalls_Mixed2, arraysize(kManyCalls_Mixed2)),
         TestScenario(kManyCalls_Mixed3, arraysize(kManyCalls_Mixed3)),
         TestScenario(kManyCalls_Mixed4, arraysize(kManyCalls_Mixed4)),
         TestScenario(kManyCalls_Mixed5, arraysize(kManyCalls_Mixed5)),
         TestScenario(kOneBigUnderrun, arraysize(kOneBigUnderrun)),
         TestScenario(kTwoBigUnderruns, arraysize(kTwoBigUnderruns)),
         TestScenario(kMixedUnderruns, arraysize(kMixedUnderruns))));
 
 }  // namespace cast
 }  // namespace media