Enable round-tripping and updating of WebSourceBufferImpl timestamp offset

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 <algorithm>
 #include <deque>
 #include <limits>
 #include <list>
@@ skipping 100 matching lines @@
   // error occurred.
   bool Append(const uint8* data, size_t length);
 
   // Aborts the current append sequence and resets the parser.
   void Abort();
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
-  // Sets |timestamp_offset_| if possible.
-  // Returns if the offset was set. Returns false if the offset could not be
-  // updated at this time.
+  // Sets user-specified |timestamp_offset_| if possible.
+  // Returns true if the offset was set. Returns false if the offset could not
+  // be set at this time.
   bool SetTimestampOffset(TimeDelta timestamp_offset);
 
+  // Gets the updated timestamp offset or indication that it has not been
+  // updated.
+  // If |using_user_specified_timestamp_offset_| is true, meaning

[acolwell GONE FROM CHROMIUM, 2014/02/25 21:50:41]

nit: I wonder if the name should be something like
timestamp_offset_updated_by_append_. It just seems like 'updated' should be in
the name of the var that controls the return value of this function.

[wolenetz, 2014/02/25 22:56:29]

Done. That does make more sense :)

+  // |timestamp_offset_| was most recently set by SetTimestampOffset() or
+  // this SourceState's construction, returns kNoTimestamp().
+  // Otherwise, returns the updated |timestamp_offset_| resulting from
+  // operations like "sequence" mode Append() coded frame processing.
+  TimeDelta GetUpdatedTimestampOffset() const;
+
   // Sets |sequence_mode_| to |sequence_mode| if possible.
   // Returns true if the mode update was allowed. Returns false if the mode
   // could not be updated at this time.
   bool SetSequenceMode(bool sequence_mode);
 
-  TimeDelta timestamp_offset() const { return timestamp_offset_; }
-
   void set_append_window_start(TimeDelta start) {
     append_window_start_ = start;
   }
   void set_append_window_end(TimeDelta end) { append_window_end_ = end; }
 
   // Returns the range of buffered data in this source, capped at |duration|.
   // |ended| - Set to true if end of stream has been signalled and the special
   // end of stream range logic needs to be executed.
   Ranges<TimeDelta> GetBufferedRanges(TimeDelta duration, bool ended) const;
 
@@ skipping 74 matching lines @@
                               bool* needs_keyframe,
                               StreamParser::BufferQueue* filtered_buffers);
 
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   IncreaseDurationCB increase_duration_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // The offset to apply to media segment timestamps.
   TimeDelta timestamp_offset_;
 
+  // Flag that is true only if |timestamp_offset_| was most recently set by
+  // SetTimestampOffset() or this SourceState's construction.
+  bool using_user_specified_timestamp_offset_;
+
   // Tracks the mode by which appended media is processed. If true, then
   // appended media is processed using "sequence" mode. Otherwise, appended
   // media is processed using "segments" mode.
   // TODO(wolenetz): Enable "sequence" mode logic. See http://crbug.com/249422
   // and http://crbug.com/333437.
   bool sequence_mode_;
 
   TimeDelta append_window_start_;
   TimeDelta append_window_end_;
 
@@ skipping 121 matching lines @@
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          const LogCB& log_cb,
                          const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                          const IncreaseDurationCB& increase_duration_cb)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       increase_duration_cb_(increase_duration_cb),
+      using_user_specified_timestamp_offset_(true),
       sequence_mode_(false),
       append_window_end_(kInfiniteDuration()),
       new_media_segment_(false),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       audio_needs_keyframe_(true),
       video_(NULL),
       video_needs_keyframe_(true),
       log_cb_(log_cb) {
@@ skipping 27 matching lines @@
                                   base::Unretained(this)),
                        base::Bind(&SourceState::OnEndOfMediaSegment,
                                   base::Unretained(this)),
                        log_cb_);
 }
 
 bool SourceState::SetTimestampOffset(TimeDelta timestamp_offset) {
   if (parsing_media_segment_)
     return false;
 
+  using_user_specified_timestamp_offset_ = true;
   timestamp_offset_ = timestamp_offset;
+
   return true;
 }
 
+TimeDelta SourceState::GetUpdatedTimestampOffset() const {
+  if (using_user_specified_timestamp_offset_)
+    return kNoTimestamp();
+
+  return timestamp_offset_;
+}
+
 bool SourceState::SetSequenceMode(bool sequence_mode) {
   if (parsing_media_segment_)
     return false;
 
   sequence_mode_ = sequence_mode;
   return true;
 }
 
 
 bool SourceState::Append(const uint8* data, size_t length) {
@@ skipping 1123 matching lines @@
 }
 
 bool ChunkDemuxer::SetTimestampOffset(const std::string& id, TimeDelta offset) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetTimestampOffset(" << id << ", " << offset.InSecondsF() << ")";
   CHECK(IsValidId(id));
 
   return source_state_map_[id]->SetTimestampOffset(offset);
 }
 
+TimeDelta ChunkDemuxer::GetUpdatedTimestampOffset(const std::string& id) {
+  base::AutoLock auto_lock(lock_);
+  DVLOG(1) << "GetUpdatedTimestampOffset(" << id << ")";
+  CHECK(IsValidId(id));
+
+  return source_state_map_[id]->GetUpdatedTimestampOffset();
+}
+
 bool ChunkDemuxer::SetSequenceMode(const std::string& id,
                                    bool sequence_mode) {
   base::AutoLock auto_lock(lock_);
   DVLOG(1) << "SetSequenceMode(" << id << ", " << sequence_mode << ")";
   CHECK(IsValidId(id));
   DCHECK_NE(state_, ENDED);
 
   return source_state_map_[id]->SetSequenceMode(sequence_mode);
 }
 
@@ skipping 293 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media