Update media duration if data is appended after the previous duration

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 74 matching lines @@
   DCHECK(!stop_pending_);
   DCHECK(!seek_pending_);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_DESTROYED));
 }
 
 void Pipeline::Start(scoped_ptr<FilterCollection> collection,
                      const PipelineStatusCB& ended_cb,
                      const PipelineStatusCB& error_cb,
-                     const PipelineStatusCB& start_cb) {
+                     const PipelineStatusCB& start_cb,
+                     const base::Closure& new_duration_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(!running_) << "Media pipeline is already running";
 
   running_ = true;
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StartTask, this, base::Passed(&collection),
-      ended_cb, error_cb, start_cb));
+      ended_cb, error_cb, start_cb, new_duration_cb));
 }
 
 void Pipeline::Stop(const base::Closure& stop_cb) {
   base::AutoLock auto_lock(lock_);
   CHECK(running_) << "Media pipeline isn't running";
 
   // Stop the pipeline, which will set |running_| to false on our behalf.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Pipeline::StopTask, this, stop_cb));
 }
@@ skipping 299 matching lines @@
   clock_->SetMaxTime(max_time);
 }
 
 void Pipeline::SetDuration(TimeDelta duration) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateTimeEvent(
           MediaLogEvent::DURATION_SET, "duration", duration));
   UMA_HISTOGRAM_LONG_TIMES("Media.Duration", duration);
 
-  base::AutoLock auto_lock(lock_);
-  clock_->SetDuration(duration);
+  base::TimeDelta old_duration;
+  {
+    base::AutoLock auto_lock(lock_);
+    old_duration = clock_->Duration();

[acolwell GONE FROM CHROMIUM, 2012/07/27 00:03:23]

nit: How about just having a duration_changed bool to control when the
new_duration_cb_ is called and only calling SetDuration() when the duration has
changed? Then SetDuration() & the callback are called under the same
circumstances which seems more consistent to me.

[vrk (LEFT CHROMIUM), 2012/07/28 01:42:05]

No longer necessary after getting rid of new_duration_cb_.

+    clock_->SetDuration(duration);
+  }
+
+  if (old_duration != duration && !new_duration_cb_.is_null())
+    new_duration_cb_.Run();
 }
 
 void Pipeline::SetTotalBytes(int64 total_bytes) {
   DCHECK(IsRunning());
   media_log_->AddEvent(
       media_log_->CreateIntegerEvent(
           MediaLogEvent::TOTAL_BYTES_SET, "total_bytes", total_bytes));
   int64 total_mbytes = total_bytes >> 20;
   if (total_mbytes > kint32max)
     total_mbytes = kint32max;
@@ skipping 139 matching lines @@
   base::AutoLock auto_lock(lock_);
   statistics_.audio_bytes_decoded += stats.audio_bytes_decoded;
   statistics_.video_bytes_decoded += stats.video_bytes_decoded;
   statistics_.video_frames_decoded += stats.video_frames_decoded;
   statistics_.video_frames_dropped += stats.video_frames_dropped;
 }
 
 void Pipeline::StartTask(scoped_ptr<FilterCollection> filter_collection,
                          const PipelineStatusCB& ended_cb,
                          const PipelineStatusCB& error_cb,
-                         const PipelineStatusCB& start_cb) {
+                         const PipelineStatusCB& start_cb,
+                         const base::Closure& new_duration_cb) {

[acolwell GONE FROM CHROMIUM, 2012/07/27 00:03:23]

WDYT about just having WebMediaPlayerImpl or even HTMLMediaElement call
duration() before and after a sourceAppend() or sourceEndOfStream() to check for
duration changes? Could that work? I'm just worried about JavaScript visible
inconsistancy between duration, HTMLMediaElement.buffered, and
SourceBuffer.buffered since this callback requires a thread hop. If no
inconsistency is visible then I'm fine with the callback.

[vrk (LEFT CHROMIUM), 2012/07/28 01:42:05]

Done (in WebMediaPlayerImpl) and I agree, this is superior! I didn't feel good
about adding this callback so I'm glad I can remove it!

   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(kCreated, state_);
   filter_collection_ = filter_collection.Pass();
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   seek_cb_ = start_cb;
+  new_duration_cb_ = new_duration_cb;
 
   // Kick off initialization.
   pipeline_init_state_.reset(new PipelineInitState());
 
   SetState(kInitDemuxer);
   InitializeDemuxer();
 }
 
 // Main initialization method called on the pipeline thread.  This code attempts
 // to use the specified filter factory to build a pipeline.
@@ skipping 664 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media