Replace erroneous use of base::Time with base::TimeTicks throughout media code.

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 31 matching lines @@
     const scoped_refptr<base::MessageLoopProxy>& message_loop,
     media::AudioRendererSink* sink,
     ScopedVector<AudioDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     bool increase_preroll_on_underflow)
     : message_loop_(message_loop),
       weak_factory_(this),
       sink_(sink),
       decoder_selector_(new AudioDecoderSelector(
           message_loop, decoders.Pass(), set_decryptor_ready_cb)),
-      now_cb_(base::Bind(&base::Time::Now)),
+      now_cb_(base::Bind(&base::TimeTicks::Now)),
       state_(kUninitialized),
       sink_playing_(false),
       pending_read_(false),
       received_end_of_stream_(false),
       rendered_end_of_stream_(false),
       audio_time_buffered_(kNoTimestamp()),
       current_time_(kNoTimestamp()),
       underflow_disabled_(false),
       increase_preroll_on_underflow_(increase_preroll_on_underflow),
       preroll_aborted_(false),
@@ skipping 454 matching lines @@
     // more audio data or at least use a delayed callback.
     //
     // 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.
     frames_written = algorithm_->FillBuffer(dest, requested_frames);
     if (frames_written == 0) {
-      base::Time now = now_cb_.Run();
+      const base::TimeTicks now = now_cb_.Run();
 
       if (received_end_of_stream_ && !rendered_end_of_stream_ &&
           now >= earliest_end_time_) {
         rendered_end_of_stream_ = true;
         ended_cb_.Run();
       } else if (!received_end_of_stream_ && state_ == kPlaying &&
                  !underflow_disabled_) {
         state_ = kUnderflow;
         underflow_cb = underflow_cb_;
       } else {
@@ skipping 53 matching lines @@
     time_cb_.Run(current_time, max_time);
   }
 
   if (!underflow_cb.is_null())
     underflow_cb.Run();
 
   return frames_written;
 }
 
 void AudioRendererImpl::UpdateEarliestEndTime_Locked(
-    int frames_filled, base::TimeDelta playback_delay, base::Time time_now) {
+    int frames_filled, const base::TimeDelta& playback_delay,
+    const base::TimeTicks& time_now) {
   if (frames_filled <= 0)
     return;
 
   base::TimeDelta predicted_play_time = base::TimeDelta::FromMicroseconds(
       static_cast<float>(frames_filled) * base::Time::kMicrosecondsPerSecond /
       audio_parameters_.sample_rate());
 
   lock_.AssertAcquired();
   earliest_end_time_ = std::max(
       earliest_end_time_, time_now + playback_delay + predicted_play_time);
@@ skipping 29 matching lines @@
     case kUnderflow:
     case kRebuffering:
     case kStopped:
       if (status != PIPELINE_OK)
         error_cb_.Run(status);
       return;
   }
 }
 
 }  // namespace media