Update media::AudioClock API to take time since writing into account.

media/filters/audio_renderer_impl.cc

 // Copyright (c) 2012 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/filters/audio_renderer_impl.h"
 
 #include <math.h>
 
 #include <algorithm>
 
@@ skipping 570 matching lines @@
     //   3) We haven't already signalled that we've ended
     //   4) We've played all known audio data sent to hardware
     //
     // We use the following conditions to determine underflow:
     //   1) Algorithm can not fill the audio callback buffer
     //   2) We have NOT received an end of stream buffer
     //   3) We are in the kPlaying state
     //
     // Otherwise the buffer has data we can send to the device.
     const base::TimeDelta media_timestamp_before_filling =
-        audio_clock_->CurrentMediaTimestamp();
+        audio_clock_->CurrentMediaTimestamp(base::TimeDelta());
     if (algorithm_->frames_buffered() > 0) {
       frames_written = algorithm_->FillBuffer(audio_bus, requested_frames);
       audio_clock_->WroteAudio(
           frames_written, delay_frames, playback_rate, algorithm_->GetTime());
     }
     audio_clock_->WroteSilence(requested_frames - frames_written, delay_frames);
 
     if (frames_written == 0) {
       if (received_end_of_stream_ && !rendered_end_of_stream_ &&
-          audio_clock_->CurrentMediaTimestamp() ==
+          audio_clock_->CurrentMediaTimestamp(base::TimeDelta()) ==
               audio_clock_->last_endpoint_timestamp()) {
         rendered_end_of_stream_ = true;
         ended_cb_.Run();
       } else if (!received_end_of_stream_ && state_ == kPlaying) {
         if (buffering_state_ != BUFFERING_HAVE_NOTHING) {
           algorithm_->IncreaseQueueCapacity();
           SetBufferingState_Locked(BUFFERING_HAVE_NOTHING);
         }
       }
     }
 
     if (CanRead_Locked()) {
       task_runner_->PostTask(FROM_HERE,
                              base::Bind(&AudioRendererImpl::AttemptRead,
                                         weak_factory_.GetWeakPtr()));
     }
 
     // We only want to execute |time_cb_| if time has progressed and we haven't
     // signaled end of stream yet.
     if (media_timestamp_before_filling !=
-            audio_clock_->CurrentMediaTimestamp() &&
+            audio_clock_->CurrentMediaTimestamp(base::TimeDelta()) &&
         !rendered_end_of_stream_) {
-      time_cb = base::Bind(time_cb_,
-                           audio_clock_->CurrentMediaTimestamp(),
-                           audio_clock_->last_endpoint_timestamp());
+      time_cb =
+          base::Bind(time_cb_,
+                     audio_clock_->CurrentMediaTimestamp(base::TimeDelta()),
+                     audio_clock_->last_endpoint_timestamp());
     }
   }
 
   if (!time_cb.is_null())
     task_runner_->PostTask(FROM_HERE, time_cb);
 
   DCHECK_LE(frames_written, requested_frames);
   return frames_written;
 }
 
@@ skipping 63 matching lines @@
            << buffering_state;
   DCHECK_NE(buffering_state_, buffering_state);
   lock_.AssertAcquired();
   buffering_state_ = buffering_state;
 
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(buffering_state_cb_, buffering_state_));
 }
 
 }  // namespace media