Fix ChunkDemuxer so appending triggers progress events.

media/filters/chunk_demuxer.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/filters/chunk_demuxer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 122 matching lines @@
   void AddBuffers(const BufferQueue& buffers);
   void Shutdown();
 
   // Gets the time range buffered by this object.
   // Returns true if there is buffered data. |start_out| & |end_out| are set to
   //    the start and end time of the buffered data respectively.
   // Returns false if no data is buffered.
   bool GetBufferedRange(base::TimeDelta* start_out,
                         base::TimeDelta* end_out) const;
 
-  bool GetLastBufferTimestamp(base::TimeDelta* timestamp) const;
-
   // DemuxerStream methods.
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual Type type() OVERRIDE;
   virtual void EnableBitstreamConverter() OVERRIDE;
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
 
  protected:
   virtual ~ChunkDemuxerStream();
 
@@ skipping 162 matching lines @@
   *start_out = buffers_.front()->GetTimestamp();
   *end_out = buffers_.back()->GetTimestamp();
 
   base::TimeDelta end_duration = buffers_.back()->GetDuration();
   if (end_duration != kNoTimestamp())
     *end_out += end_duration;
 
   return true;
 }
 
-bool ChunkDemuxerStream::GetLastBufferTimestamp(
-    base::TimeDelta* timestamp) const {
-  base::AutoLock auto_lock(lock_);
-
-  if (buffers_.empty())
-    return false;
-
-  *timestamp = buffers_.back()->GetTimestamp();
-  return true;
-}
-
 // Helper function that makes sure |read_cb| runs on |message_loop|.
 static void RunOnMessageLoop(const DemuxerStream::ReadCB& read_cb,
                              MessageLoop* message_loop,
                              const scoped_refptr<Buffer>& buffer) {
   if (MessageLoop::current() != message_loop) {
     message_loop->PostTask(FROM_HERE, base::Bind(
         &RunOnMessageLoop, read_cb, message_loop, buffer));
     return;
   }
 
@@ skipping 312 matching lines @@
     AddId(id, "video/webm", codecs);
   }
 
   DCHECK(!source_id_.empty());
   DCHECK_EQ(source_id_, id);
   DCHECK(!id.empty());
   DCHECK(data);
   DCHECK_GT(length, 0u);
 
   int64 buffered_bytes = 0;
-  base::TimeDelta buffered_ts = base::TimeDelta::FromSeconds(-1);
 
   PipelineStatusCB cb;
   {
     base::AutoLock auto_lock(lock_);
 
     // Capture |seek_waits_for_data_| state before we start parsing.
     // Its state can be changed by OnAudioBuffers() or OnVideoBuffers()
     // calls during the parse.
     bool old_seek_waits_for_data = seek_waits_for_data_;
 
@@ skipping 21 matching lines @@
         return false;
     }
 
     // Check to see if parsing triggered seek_waits_for_data_ to go from true to
     // false. This indicates we have parsed enough data to complete the seek.
     if (old_seek_waits_for_data && !seek_waits_for_data_ &&
         !seek_cb_.is_null()) {
       std::swap(cb, seek_cb_);
     }
 
-    base::TimeDelta tmp;
-    if (audio_.get() && audio_->GetLastBufferTimestamp(&tmp) &&
-        tmp > buffered_ts) {
-      buffered_ts = tmp;
-    }
-
-    if (video_.get() && video_->GetLastBufferTimestamp(&tmp) &&
-        tmp > buffered_ts) {
-      buffered_ts = tmp;
-    }
-
+    buffered_bytes_ += length;
     buffered_bytes = buffered_bytes_;
   }
 
   // Notify the host of 'network activity' because we got data.
   host_->SetBufferedBytes(buffered_bytes);
 
   host_->SetNetworkActivity(true);
 
   if (!cb.is_null())
     cb.Run(PIPELINE_OK);
@@ skipping 182 matching lines @@
   return true;
 }
 
 bool ChunkDemuxer::OnKeyNeeded(scoped_array<uint8> init_data,
                                int init_data_size) {
   client_->KeyNeeded(init_data.Pass(), init_data_size);
   return true;
 }
 
 }  // namespace media