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

media/base/android/media_source_player.cc

 // Copyright (c) 2013 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/base/android/media_source_player.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 67 matching lines @@
   VideoDecoderJob(
       const VideoCodec video_codec, const gfx::Size& size, jobject surface);
   virtual ~VideoDecoderJob() {}
 
   void Configure(
       const VideoCodec codec, const gfx::Size& size, jobject surface);
 };
 
 void MediaDecoderJob::Decode(
     const MediaPlayerHostMsg_ReadFromDemuxerAck_Params::AccessUnit& unit,
-    const base::Time& start_wallclock_time,
+    const base::TimeTicks& start_wallclock_time,
     const base::TimeDelta& start_presentation_timestamp,
     const MediaDecoderJob::DecoderCallback& callback) {
   DCHECK(!decoding_);
   decoding_ = true;
   thread_->message_loop()->PostTask(FROM_HERE, base::Bind(
       &MediaDecoderJob::DecodeInternal, base::Unretained(this), unit,
       start_wallclock_time, start_presentation_timestamp, needs_flush_,
       callback));
   needs_flush_ = false;
 }
 
 void MediaDecoderJob::DecodeInternal(
     const MediaPlayerHostMsg_ReadFromDemuxerAck_Params::AccessUnit& unit,
-    const base::Time& start_wallclock_time,
+    const base::TimeTicks& start_wallclock_time,
     const base::TimeDelta& start_presentation_timestamp,
     bool needs_flush,
     const MediaDecoderJob::DecoderCallback& callback) {
   if (needs_flush)
     media_codec_bridge_->Reset();
   base::TimeDelta timeout = base::TimeDelta::FromMicroseconds(
       kMediaCodecTimeoutInMicroseconds);
   int input_buf_index = media_codec_bridge_->DequeueInputBuffer(timeout);
   if (input_buf_index == MediaCodecBridge::INFO_MEDIA_CODEC_ERROR) {
     message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 31 matching lines @@
       break;
     case MediaCodecBridge::INFO_MEDIA_CODEC_ERROR:
       decode_status = DECODE_FAILED;
       break;
     default:
       DCHECK_LE(0, outputBufferIndex);
       if (size == 0 && end_of_stream)
         break;
       base::TimeDelta time_to_render;
       if (!start_wallclock_time.is_null()) {
-        time_to_render = presentation_timestamp - (base::Time::Now() -
+        time_to_render = presentation_timestamp - (base::TimeTicks::Now() -
             start_wallclock_time + start_presentation_timestamp);
       }
       if (time_to_render >= base::TimeDelta()) {
         base::MessageLoop::current()->PostDelayedTask(
             FROM_HERE,
             base::Bind(&MediaDecoderJob::ReleaseOutputBuffer,
                        weak_this_.GetWeakPtr(), outputBufferIndex, size,
                        presentation_timestamp, end_of_stream, callback),
             time_to_render);
       } else {
@@ skipping 16 matching lines @@
     const base::TimeDelta& presentation_timestamp,
     bool end_of_stream, const MediaDecoderJob::DecoderCallback& callback) {
   // TODO(qinmin): Refactor this function. Maybe AudioDecoderJob should provide
   // its own ReleaseOutputBuffer().
   if (is_audio_) {
     static_cast<AudioCodecBridge*>(media_codec_bridge_.get())->PlayOutputBuffer(
         outputBufferIndex, size);
   }
   media_codec_bridge_->ReleaseOutputBuffer(outputBufferIndex, !is_audio_);
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      callback, DECODE_SUCCEEDED, presentation_timestamp, base::Time::Now(),
-      end_of_stream));
+      callback, DECODE_SUCCEEDED, presentation_timestamp,
+      base::TimeTicks::Now(), end_of_stream));
 }
 
 void MediaDecoderJob::OnDecodeCompleted() {
   decoding_ = false;
 }
 
 void MediaDecoderJob::Flush() {
   // Do nothing, flush when the next Decode() happens.
   needs_flush_ = true;
 }
@@ skipping 90 matching lines @@
   playing_ = true;
 
   CreateAudioDecoderJob();
   CreateVideoDecoderJob();
 
   StartInternal();
 }
 
 void MediaSourcePlayer::Pause() {
   playing_ = false;
-  start_wallclock_time_ = base::Time();
+  start_wallclock_time_ = base::TimeTicks();
 }
 
 bool MediaSourcePlayer::IsPlaying() {
   return playing_;
 }
 
 int MediaSourcePlayer::GetVideoWidth() {
   return width_;
 }
 
@@ skipping 128 matching lines @@
   // Do nothing until the most recent seek request is processed.
   if (seek_request_id_ != seek_request_id)
     return;
   pending_event_ &= ~SEEK_EVENT_PENDING;
   OnSeekComplete();
   ProcessPendingEvents();
 }
 
 void MediaSourcePlayer::UpdateTimestamps(
     const base::TimeDelta& presentation_timestamp,
-    const base::Time& wallclock_time) {
+    const base::TimeTicks& wallclock_time) {
   last_presentation_timestamp_ = presentation_timestamp;
   OnTimeUpdated();
   if (start_wallclock_time_.is_null() && playing_) {
     start_wallclock_time_ = wallclock_time;
     start_presentation_timestamp_ = last_presentation_timestamp_;
   }
 }
 
 void MediaSourcePlayer::ProcessPendingEvents() {
   // Wait for all the decoding jobs to finish before processing pending tasks.
   if (active_decoding_tasks_ > 0)
     return;
 
   if (pending_event_ & SEEK_EVENT_PENDING) {
     ClearDecodingData();
     manager()->OnMediaSeekRequest(
         player_id(), last_presentation_timestamp_, ++seek_request_id_);
     return;
   }
 
-  start_wallclock_time_ = base::Time();
+  start_wallclock_time_ = base::TimeTicks();
   if (pending_event_ & CONFIG_CHANGE_EVENT_PENDING) {
     DCHECK(reconfig_audio_decoder_ || reconfig_video_decoder_);
     manager()->OnMediaConfigRequest(player_id());
     return;
   }
 
   if (pending_event_ & SURFACE_CHANGE_EVENT_PENDING) {
     video_decoder_job_.reset();
     CreateVideoDecoderJob();
     pending_event_ &= ~SURFACE_CHANGE_EVENT_PENDING;
   }
 
   if (playing_ && pending_event_ == NO_EVENT_PENDING)
     StartInternal();
 }
 
 void MediaSourcePlayer::MediaDecoderCallback(
     bool is_audio, MediaDecoderJob::DecodeStatus decode_status,
     const base::TimeDelta& presentation_timestamp,
-    const base::Time& wallclock_time, bool end_of_stream) {
+    const base::TimeTicks& wallclock_time, bool end_of_stream) {
   if (active_decoding_tasks_ > 0)
     active_decoding_tasks_--;
 
   if (is_audio && audio_decoder_job_)
     audio_decoder_job_->OnDecodeCompleted();
   if (!is_audio && video_decoder_job_)
     video_decoder_job_->OnDecodeCompleted();
 
   if (decode_status == MediaDecoderJob::DECODE_FAILED) {
     Release();
@@ skipping 90 matching lines @@
 
 
 void MediaSourcePlayer::PlaybackCompleted(bool is_audio) {
   if (is_audio)
     audio_finished_ = true;
   else
     video_finished_ = true;
 
   if ((!HasAudio() || audio_finished_) && (!HasVideo() || video_finished_)) {
     playing_ = false;
-    start_wallclock_time_ = base::Time();
+    start_wallclock_time_ = base::TimeTicks();
     OnPlaybackComplete();
   }
 }
 
 void MediaSourcePlayer::ClearDecodingData() {
   if (audio_decoder_job_)
     audio_decoder_job_->Flush();
   if (video_decoder_job_)
     video_decoder_job_->Flush();
-  start_wallclock_time_ = base::Time();
+  start_wallclock_time_ = base::TimeTicks();
   received_audio_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
   received_video_ = MediaPlayerHostMsg_ReadFromDemuxerAck_Params();
   audio_access_unit_index_ = 0;
   video_access_unit_index_ = 0;
 }
 
 bool MediaSourcePlayer::HasVideo() {
   return kUnknownVideoCodec != video_codec_;
 }
 
@@ skipping 28 matching lines @@
     reconfig_video_decoder_ = false;
   }
 
   // Inform the fullscreen view the player is ready.
   // TODO(qinmin): refactor MediaPlayerBridge so that we have a better way
   // to inform ContentVideoView.
   OnMediaMetadataChanged(duration_, width_, height_, true);
 }
 
 }  // namespace media