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

media/audio/linux/alsa_input.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/audio/linux/alsa_input.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 101 matching lines @@
       HandleError("PcmStart", error);
   }
 
   if (error < 0) {
     callback_ = NULL;
   } else {
     // We start reading data half |buffer_duration_| later than when the
     // buffer might have got filled, to accommodate some delays in the audio
     // driver. This could also give us a smooth read sequence going forward.
     base::TimeDelta delay = buffer_duration_ + buffer_duration_ / 2;
-    next_read_time_ = base::Time::Now() + delay;
+    next_read_time_ = base::TimeTicks::Now() + delay;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
         delay);
   }
 }
 
 bool AlsaPcmInputStream::Recover(int original_error) {
   int error = wrapper_->PcmRecover(device_handle_, original_error, 1);
   if (error < 0) {
@@ skipping 42 matching lines @@
     LOG(WARNING) << "PcmAvailUpdate(): " << wrapper_->StrError(frames);
     Recover(frames);
   }
 
   if (frames < params_.frames_per_buffer()) {
     // Not enough data yet or error happened. In both cases wait for a very
     // small duration before checking again.
     // Even Though read callback was behind schedule, there is no data, so
     // reset the next_read_time_.
     if (read_callback_behind_schedule_) {
-      next_read_time_ = base::Time::Now();
+      next_read_time_ = base::TimeTicks::Now();
       read_callback_behind_schedule_ = false;
     }
 
     base::TimeDelta next_check_time = buffer_duration_ / 2;
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&AlsaPcmInputStream::ReadAudio, weak_factory_.GetWeakPtr()),
         next_check_time);
     return;
   }
@@ skipping 15 matching lines @@
       callback_->OnData(this, audio_buffer_.get(), bytes_per_buffer_,
                         hardware_delay_bytes, normalized_volume);
     } else {
       LOG(WARNING) << "PcmReadi returning less than expected frames: "
                    << frames_read << " vs. " << params_.frames_per_buffer()
                    << ". Dropping this buffer.";
     }
   }
 
   next_read_time_ += buffer_duration_;
-  base::TimeDelta delay = next_read_time_ - base::Time::Now();
+  base::TimeDelta delay = next_read_time_ - base::TimeTicks::Now();
   if (delay < base::TimeDelta()) {
     DVLOG(1) << "Audio read callback behind schedule by "
              << (buffer_duration_ - delay).InMicroseconds()
              << " (us).";
     // Read callback is behind schedule. Assuming there is data pending in
     // the soundcard, invoke the read callback immediate in order to catch up.
     read_callback_behind_schedule_ = true;
     delay = base::TimeDelta();
   }
 
@@ skipping 99 matching lines @@
 
   return static_cast<double>(current_volume);
 }
 
 void AlsaPcmInputStream::HandleError(const char* method, int error) {
   LOG(WARNING) << method << ": " << wrapper_->StrError(error);
   callback_->OnError(this);
 }
 
 }  // namespace media