Make media::AudioClock track frames written to compute time.

media/filters/audio_clock_unittest.cc

Index: media/filters/audio_clock_unittest.cc
diff --git a/media/filters/audio_clock_unittest.cc b/media/filters/audio_clock_unittest.cc
index 00179f9094fda648251732c5e4c384b97b2a66f4..4bb019704683f2a797b256df94bcb87e4a74e48f 100644
--- a/media/filters/audio_clock_unittest.cc
+++ b/media/filters/audio_clock_unittest.cc
@@ -12,22 +12,20 @@ namespace media {
 class AudioClockTest : public testing::Test {
  public:
   AudioClockTest()
-      : sample_rate_(10),
-        timestamp_helper_(sample_rate_),
-        clock_(sample_rate_) {
-    timestamp_helper_.SetBaseTimestamp(base::TimeDelta());
-  }
+      : sample_rate_(10), clock_(base::TimeDelta(), sample_rate_) {}
 
   virtual ~AudioClockTest() {}
 
-  void WroteAudio(int frames, int delay_frames, float playback_rate) {
-    timestamp_helper_.AddFrames(static_cast<int>(frames * playback_rate));
+  void WroteAudio(int frames_written,
+                  int frames_requested,
+                  int delay_frames,
+                  float playback_rate) {
     clock_.WroteAudio(
-        frames, delay_frames, playback_rate, timestamp_helper_.GetTimestamp());
+        frames_written, frames_requested, delay_frames, playback_rate);
   }
 
-  void WroteSilence(int frames, int delay_frames) {
-    clock_.WroteSilence(frames, delay_frames);
+  int CurrentMediaTimestampInDays() {
+    return clock_.CurrentMediaTimestamp(base::TimeDelta()).InDays();
   }
 
   int CurrentMediaTimestampInMilliseconds() {
@@ -39,144 +37,200 @@ class AudioClockTest : public testing::Test {
                                             milliseconds)).InMilliseconds();
   }
 
-  int LastEndpointTimestampInMilliseconds() {
-    return clock_.last_endpoint_timestamp().InMilliseconds();
+  int ContiguousAudioDataBufferedInDays() {
+    return clock_.ContiguousAudioDataBuffered().InDays();
+  }
+
+  int ContiguousAudioDataBufferedInMilliseconds() {
+    return clock_.ContiguousAudioDataBuffered().InMilliseconds();
+  }
+
+  int ContiguousAudioDataBufferedAtSameRateInMilliseconds() {
+    return clock_.ContiguousAudioDataBufferedAtSameRate().InMilliseconds();
   }
 
   const int sample_rate_;
-  AudioTimestampHelper timestamp_helper_;
   AudioClock clock_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(AudioClockTest);
 };
 
-TEST_F(AudioClockTest, TimestampsStartAtNoTimestamp) {
-  EXPECT_EQ(kNoTimestamp(), clock_.CurrentMediaTimestamp(base::TimeDelta()));
-  EXPECT_EQ(kNoTimestamp(), clock_.last_endpoint_timestamp());
+TEST_F(AudioClockTest, CurrentMediaTimestampsStartsAtStartTimestamp) {
+  base::TimeDelta expected = base::TimeDelta::FromSeconds(123);
+  AudioClock clock(expected, sample_rate_);
+
+  EXPECT_EQ(expected, clock.CurrentMediaTimestamp(base::TimeDelta()));
+}
+
+TEST_F(AudioClockTest, ContiguousAudioDataBufferedStartsAtZero) {
+  EXPECT_EQ(base::TimeDelta(), clock_.ContiguousAudioDataBuffered());
+}
+
+TEST_F(AudioClockTest, AudioDataBufferedStartsAtFalse) {
+  EXPECT_FALSE(clock_.AudioDataBuffered());
 }
 
 TEST_F(AudioClockTest, Playback) {
-  // The first time we write data we should expect a negative time matching the
-  // current delay.
-  WroteAudio(10, 20, 1.0);
-  EXPECT_EQ(-2000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(1000, LastEndpointTimestampInMilliseconds());
-
-  // The media time should keep advancing as we write data.
-  WroteAudio(10, 20, 1.0);
-  EXPECT_EQ(-1000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(2000, LastEndpointTimestampInMilliseconds());
-
-  WroteAudio(10, 20, 1.0);
+  // The first time we write data we should still expect our start timestamp
+  // due to delay.
+  WroteAudio(10, 10, 20, 1.0);
+  EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+  EXPECT_TRUE(clock_.AudioDataBuffered());
+
+  // The media time should remain at start timestamp as we write data.
+  WroteAudio(10, 10, 20, 1.0);
+  EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+
+  WroteAudio(10, 10, 20, 1.0);
   EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(3000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  WroteAudio(10, 20, 1.0);
+  // The media time should now start advanced now that delay has been covered.
+  WroteAudio(10, 10, 20, 1.0);
   EXPECT_EQ(1000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(4000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  // Introduce a rate change to slow down time. Current time will keep advancing
-  // by one second until it hits the slowed down audio.
-  WroteAudio(10, 20, 0.5);
+  WroteAudio(10, 10, 20, 1.0);
   EXPECT_EQ(2000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(4500, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  WroteAudio(10, 20, 0.5);
+  // Introduce a rate change to slow down time:
+  //   - Current time will advance by one second until it hits rate change
+  //   - Contiguous audio data will start shrinking immediately
+  WroteAudio(10, 10, 20, 0.5);
   EXPECT_EQ(3000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(5000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(2500, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(2000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  WroteAudio(10, 20, 0.5);
+  WroteAudio(10, 10, 20, 0.5);
   EXPECT_EQ(4000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(5500, LastEndpointTimestampInMilliseconds());
-
-  WroteAudio(10, 20, 0.5);
-  EXPECT_EQ(4500, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(6000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(2000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  // Introduce a rate change to speed up time. Current time will keep advancing
-  // by half a second until it hits the the sped up audio.
-  WroteAudio(10, 20, 2);
+  WroteAudio(10, 10, 20, 0.5);
   EXPECT_EQ(5000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(8000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(1500, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(1500, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  WroteAudio(10, 20, 2);
+  WroteAudio(10, 10, 20, 0.5);
   EXPECT_EQ(5500, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(10000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(1500, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(1500, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
 
-  WroteAudio(10, 20, 2);
+  // Introduce a rate change to speed up time:
+  //   - Current time will advance by half a second until it hits rate change
+  //   - Contiguous audio data will start growing immediately
+  WroteAudio(10, 10, 20, 2);
   EXPECT_EQ(6000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(12000, LastEndpointTimestampInMilliseconds());
-
-  WroteAudio(10, 20, 2);
-  EXPECT_EQ(8000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(14000, LastEndpointTimestampInMilliseconds());
-
-  // Write silence to simulate reaching end of stream.
-  WroteSilence(10, 20);
-  EXPECT_EQ(10000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(14000, LastEndpointTimestampInMilliseconds());
-
-  WroteSilence(10, 20);
-  EXPECT_EQ(12000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(14000, LastEndpointTimestampInMilliseconds());
-
-  WroteSilence(10, 20);
-  EXPECT_EQ(14000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(14000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(3000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+
+  WroteAudio(10, 10, 20, 2);
+  EXPECT_EQ(6500, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(4500, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(500, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+
+  WroteAudio(10, 10, 20, 2);
+  EXPECT_EQ(7000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(6000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(6000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+
+  WroteAudio(10, 10, 20, 2);
+  EXPECT_EQ(9000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(6000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(6000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+
+  // Write silence to simulate reaching end of stream:
+  //   - Current time will advance by half a second until it hits silence
+  //   - Contiguous audio data will start shrinking towards zero
+  WroteAudio(0, 10, 20, 2);
+  EXPECT_EQ(11000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(4000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(4000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+
+  WroteAudio(0, 10, 20, 2);
+  EXPECT_EQ(13000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(2000, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(2000, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+  EXPECT_TRUE(clock_.AudioDataBuffered());  // Still audio data buffered.
+
+  WroteAudio(0, 10, 20, 2);
+  EXPECT_EQ(15000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+  EXPECT_FALSE(clock_.AudioDataBuffered());  // No more audio data buffered.
 
   // At this point media time should stop increasing.
-  WroteSilence(10, 20);
-  EXPECT_EQ(14000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(14000, LastEndpointTimestampInMilliseconds());
+  WroteAudio(0, 10, 20, 2);
+  EXPECT_EQ(15000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedAtSameRateInMilliseconds());
+  EXPECT_FALSE(clock_.AudioDataBuffered());
 }
 
 TEST_F(AudioClockTest, AlternatingAudioAndSilence) {
   // Buffer #1: [0, 1000)
-  WroteAudio(10, 20, 1.0);
-  EXPECT_EQ(-2000, CurrentMediaTimestampInMilliseconds());
+  WroteAudio(10, 10, 20, 1.0);
+  EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 
   // Buffer #2: 1000ms of silence
-  WroteSilence(10, 20);
-  EXPECT_EQ(-1000, CurrentMediaTimestampInMilliseconds());
-
-  // Buffer #3: [1000, 2000), buffer #1 is at front
-  WroteAudio(10, 20, 1.0);
+  WroteAudio(0, 10, 20, 1.0);
   EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 
-  // Buffer #4: 1000ms of silence, time shouldn't advance
-  WroteSilence(10, 20);
+  // Buffer #3: [1000, 2000):
+  //   - Buffer #1 is at front with 1000ms of contiguous audio data
+  WroteAudio(10, 10, 20, 1.0);
   EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
+
+  // Buffer #4: 1000ms of silence
+  //   - Buffer #1 has been played out
+  //   - Buffer #2 of silence leaves us with 0ms of contiguous audio data
+  WroteAudio(0, 10, 20, 1.0);
+  EXPECT_EQ(1000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 
-  // Buffer #5: [2000, 3000), buffer #3 is at front
-  WroteAudio(10, 20, 1.0);
+  // Buffer #5: [2000, 3000):
+  //   - Buffer #3 is at front with 1000ms of contiguous audio data
+  WroteAudio(10, 10, 20, 1.0);
   EXPECT_EQ(1000, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
 }
 
 TEST_F(AudioClockTest, ZeroDelay) {
   // The first time we write data we should expect the first timestamp
   // immediately.
-  WroteAudio(10, 0, 1.0);
+  WroteAudio(10, 10, 0, 1.0);
   EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(1000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
 
   // Ditto for all subsequent buffers.
-  WroteAudio(10, 0, 1.0);
+  WroteAudio(10, 10, 0, 1.0);
   EXPECT_EQ(1000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(2000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
 
-  WroteAudio(10, 0, 1.0);
+  WroteAudio(10, 10, 0, 1.0);
   EXPECT_EQ(2000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(3000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(1000, ContiguousAudioDataBufferedInMilliseconds());
 
   // Ditto for silence.
-  WroteSilence(10, 0);
+  WroteAudio(0, 10, 0, 1.0);
   EXPECT_EQ(3000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(3000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 
-  WroteSilence(10, 0);
+  WroteAudio(0, 10, 0, 1.0);
   EXPECT_EQ(3000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(3000, LastEndpointTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 }
 
 TEST_F(AudioClockTest, CurrentMediaTimestampSinceLastWriting) {
@@ -187,20 +241,20 @@ TEST_F(AudioClockTest, CurrentMediaTimestampSinceLastWriting) {
   // +-------------------+----------------+------------------+----------------+
   // Media timestamp:    0              1000               1500             3500
   // Wall clock time:  2000             3000               4000             5000
-  WroteAudio(10, 40, 1.0);
-  WroteAudio(10, 40, 0.5);
-  WroteAudio(10, 40, 2.0);
-  EXPECT_EQ(-2000, CurrentMediaTimestampInMilliseconds());
-  EXPECT_EQ(3500, LastEndpointTimestampInMilliseconds());
+  WroteAudio(10, 10, 40, 1.0);
+  WroteAudio(10, 10, 40, 0.5);
+  WroteAudio(10, 10, 40, 2.0);
+  EXPECT_EQ(0, CurrentMediaTimestampInMilliseconds());
+  EXPECT_EQ(0, ContiguousAudioDataBufferedInMilliseconds());
 
   // Simulate passing 2000ms of initial delay in the audio hardware.
-  EXPECT_EQ(-2000, CurrentMediaTimestampSinceLastWritingInMilliseconds(0));
-  EXPECT_EQ(-1500, CurrentMediaTimestampSinceLastWritingInMilliseconds(500));
-  EXPECT_EQ(-1000, CurrentMediaTimestampSinceLastWritingInMilliseconds(1000));
-  EXPECT_EQ(-500, CurrentMediaTimestampSinceLastWritingInMilliseconds(1500));
+  EXPECT_EQ(0, CurrentMediaTimestampSinceLastWritingInMilliseconds(0));
+  EXPECT_EQ(0, CurrentMediaTimestampSinceLastWritingInMilliseconds(500));
+  EXPECT_EQ(0, CurrentMediaTimestampSinceLastWritingInMilliseconds(1000));
+  EXPECT_EQ(0, CurrentMediaTimestampSinceLastWritingInMilliseconds(1500));
   EXPECT_EQ(0, CurrentMediaTimestampSinceLastWritingInMilliseconds(2000));
 
-  // New we should see the 1.0x buffer.
+  // Now we should see the 1.0x buffer.
   EXPECT_EQ(500, CurrentMediaTimestampSinceLastWritingInMilliseconds(2500));
   EXPECT_EQ(1000, CurrentMediaTimestampSinceLastWritingInMilliseconds(3000));
 
@@ -213,11 +267,40 @@ TEST_F(AudioClockTest, CurrentMediaTimestampSinceLastWriting) {
   EXPECT_EQ(3500, CurrentMediaTimestampSinceLastWritingInMilliseconds(5000));
 
   // Times beyond the known length of the audio clock should return the last
-  // value we know of.
-  EXPECT_EQ(LastEndpointTimestampInMilliseconds(),
-            CurrentMediaTimestampSinceLastWritingInMilliseconds(5001));
-  EXPECT_EQ(LastEndpointTimestampInMilliseconds(),
-            CurrentMediaTimestampSinceLastWritingInMilliseconds(6000));
+  // media timestamp we know of.
+  EXPECT_EQ(3500, CurrentMediaTimestampSinceLastWritingInMilliseconds(5001));
+  EXPECT_EQ(3500, CurrentMediaTimestampSinceLastWritingInMilliseconds(6000));
+}
+
+TEST_F(AudioClockTest, SupportsYearsWorthOfAudioData) {
+  // Use number of frames that would be likely to overflow 32-bit integer math.
+  const int huge_amount_of_frames = std::numeric_limits<int>::max();
+  const base::TimeDelta huge =
+      base::TimeDelta::FromSeconds(huge_amount_of_frames / sample_rate_);
+  EXPECT_EQ(2485, huge.InDays());  // Just to give some context on how big...
+
+  // Use zero delay to test calculation of current timestamp.
+  WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
+  EXPECT_EQ(0, CurrentMediaTimestampInDays());
+  EXPECT_EQ(2485, ContiguousAudioDataBufferedInDays());
+
+  WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
+  EXPECT_EQ(huge.InDays(), CurrentMediaTimestampInDays());
+  EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
+
+  WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
+  EXPECT_EQ((huge * 2).InDays(), CurrentMediaTimestampInDays());
+  EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
+
+  WroteAudio(huge_amount_of_frames, huge_amount_of_frames, 0, 1.0);
+  EXPECT_EQ((huge * 3).InDays(), CurrentMediaTimestampInDays());
+  EXPECT_EQ(huge.InDays(), ContiguousAudioDataBufferedInDays());
+
+  // Use huge delay to test calculation of buffered data.
+  WroteAudio(
+      huge_amount_of_frames, huge_amount_of_frames, huge_amount_of_frames, 1.0);
+  EXPECT_EQ((huge * 3).InDays(), CurrentMediaTimestampInDays());
+  EXPECT_EQ((huge * 2).InDays(), ContiguousAudioDataBufferedInDays());
 }
 
 }  // namespace media