Revert of Fix seeking when the start time is non-zero.

media/base/pipeline.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/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 368 matching lines @@
 
     case kInitVideoRenderer:
       return InitializeVideoRenderer(done_cb);
 
     case kInitPrerolling:
       filter_collection_.reset();
       {
         base::AutoLock l(lock_);
         // We do not want to start the clock running. We only want to set the
         // base media time so our timestamp calculations will be correct.
-        clock_->SetTime(base::TimeDelta(), base::TimeDelta());
+        clock_->SetTime(demuxer_->GetStartTime(), demuxer_->GetStartTime());
       }
       if (!audio_renderer_ && !video_renderer_) {
         done_cb.Run(PIPELINE_ERROR_COULD_NOT_RENDER);
         return;
       }
 
       {
         PipelineMetadata metadata;
         metadata.has_audio = audio_renderer_;
         metadata.has_video = video_renderer_;
@@ skipping 38 matching lines @@
 // in the following DoXXX() functions is considered safe as they are owned by
 // |pending_callbacks_| and share the same lifetime.
 //
 // That being said, deleting the renderers while keeping |pending_callbacks_|
 // running on the media thread would result in crashes.
 void Pipeline::DoInitialPreroll(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
-  const base::TimeDelta seek_timestamp = base::TimeDelta();
+  base::TimeDelta seek_timestamp = demuxer_->GetStartTime();
 
   // Preroll renderers.
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()),
         seek_timestamp));
   }
 
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
@@ skipping 277 matching lines @@
     // TODO(scherkus): should we run the callback?  I'm tempted to say the API
     // will only execute the first Seek() request.
     DVLOG(1) << "Media pipeline has not started, ignoring seek to "
              << time.InMicroseconds() << " (current state: " << state_ << ")";
     return;
   }
 
   DCHECK(seek_cb_.is_null());
 
   SetState(kSeeking);
+  base::TimeDelta seek_timestamp = std::max(time, demuxer_->GetStartTime());
   seek_cb_ = seek_cb;
   audio_ended_ = false;
   video_ended_ = false;
   text_ended_ = false;
 
   // Kick off seeking!
   {
     base::AutoLock auto_lock(lock_);
     PauseClockAndStopRendering_Locked();
-    clock_->SetTime(time, time);
+    clock_->SetTime(seek_timestamp, seek_timestamp);
   }
-  DoSeek(time, base::Bind(
+  DoSeek(seek_timestamp, base::Bind(
       &Pipeline::OnStateTransition, base::Unretained(this)));
 }
 
 void Pipeline::DoAudioRendererEnded() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (state_ != kPlaying)
     return;
 
   DCHECK(!audio_ended_);
@@ skipping 208 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (clock_state_ != CLOCK_WAITING_FOR_AUDIO_TIME_UPDATE)
     return;
 
   clock_state_ = CLOCK_PLAYING;
   clock_->Play();
 }
 
 }  // namespace media