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

media/audio/audio_low_latency_input_output_unittest.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 "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 118 matching lines @@
       public AudioOutputStream::AudioSourceCallback {
  public:
   FullDuplexAudioSinkSource(int sample_rate,
                             int samples_per_packet,
                             int channels)
     : sample_rate_(sample_rate),
       samples_per_packet_(samples_per_packet),
       channels_(channels),
       input_elements_to_write_(0),
       output_elements_to_write_(0),
-      previous_write_time_(base::Time::Now()) {
+      previous_write_time_(base::TimeTicks::Now()) {
     // Size in bytes of each audio frame (4 bytes for 16-bit stereo PCM).
     frame_size_ = (16 / 8) * channels_;
 
     // Start with the smallest possible buffer size. It will be increased
     // dynamically during the test if required.
     buffer_.reset(
         new media::SeekableBuffer(0, samples_per_packet_ * frame_size_));
 
     frames_to_ms_ = static_cast<double>(1000.0 / sample_rate_);
     delay_states_.reset(new AudioDelayState[kMaxDelayMeasurements]);
@@ skipping 29 matching lines @@
 
   // AudioInputStream::AudioInputCallback.
   virtual void OnData(AudioInputStream* stream,
                       const uint8* src, uint32 size,
                       uint32 hardware_delay_bytes,
                       double volume) OVERRIDE {
     base::AutoLock lock(lock_);
 
     // Update three components in the AudioDelayState for this recorded
     // audio packet.
-    base::Time now_time = base::Time::Now();
-    int diff = (now_time - previous_write_time_).InMilliseconds();
+    const base::TimeTicks now_time = base::TimeTicks::Now();
+    const int diff = (now_time - previous_write_time_).InMilliseconds();
     previous_write_time_ = now_time;
     if (input_elements_to_write_ < kMaxDelayMeasurements) {
       delay_states_[input_elements_to_write_].delta_time_ms = diff;
       delay_states_[input_elements_to_write_].buffer_delay_ms =
           BytesToMilliseconds(buffer_->forward_bytes());
       delay_states_[input_elements_to_write_].input_delay_ms =
           BytesToMilliseconds(hardware_delay_bytes);
       ++input_elements_to_write_;
     }
 
@@ skipping 69 matching lines @@
   base::Lock lock_;
   scoped_ptr<media::SeekableBuffer> buffer_;
   int sample_rate_;
   int samples_per_packet_;
   int channels_;
   int frame_size_;
   double frames_to_ms_;
   scoped_ptr<AudioDelayState[]> delay_states_;
   size_t input_elements_to_write_;
   size_t output_elements_to_write_;
-  base::Time previous_write_time_;
+  base::TimeTicks previous_write_time_;
 };
 
 class AudioInputStreamTraits {
  public:
   typedef AudioInputStream StreamType;
 
   static AudioParameters GetDefaultAudioStreamParameters(
       AudioManager* audio_manager) {
     return audio_manager->GetInputStreamParameters(
         AudioManagerBase::kDefaultDeviceId);
@@ skipping 149 matching lines @@
 
   // All Close() operations that run on the mocked audio thread,
   // should be synchronous and not post additional close tasks to
   // mocked the audio thread. Hence, there is no need to call
   // message_loop()->RunUntilIdle() after the Close() methods.
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media