Unify media track info reporting on a demuxer level

media/filters/media_source_state.h

 // Copyright (c) 2016 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.
 
 #ifndef MEDIA_FILTERS_MEDIA_SOURCE_STATE_H_
 #define MEDIA_FILTERS_MEDIA_SOURCE_STATE_H_
 
 #include <list>
 
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 class ChunkDemuxerStream;
 class FrameProcessor;
 
 // Contains state belonging to a source id.
 class MEDIA_EXPORT MediaSourceState {
  public:
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(DemuxerStream::Type)>
       CreateDemuxerStreamCB;
 
-  typedef base::Callback<void(const MediaTracks&)> InitSegmentReceivedCB;
-
   typedef base::Callback<void(ChunkDemuxerStream*, const TextTrackConfig&)>
       NewTextTrackCB;
 
   MediaSourceState(scoped_ptr<StreamParser> stream_parser,
                    scoped_ptr<FrameProcessor> frame_processor,
                    const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                    const scoped_refptr<MediaLog>& media_log);
 
   ~MediaSourceState();
 
   void Init(const StreamParser::InitCB& init_cb,
             bool allow_audio,
             bool allow_video,
             const StreamParser::EncryptedMediaInitDataCB&
                 encrypted_media_init_data_cb,
             const NewTextTrackCB& new_text_track_cb);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred. |*timestamp_offset| is used and possibly updated by the
   // append. |append_window_start| and |append_window_end| correspond to the MSE
   // spec's similarly named source buffer attributes that are used in coded
-  // frame processing. |init_segment_received_cb| is run for each new fully
-  // parsed initialization segment.
+  // frame processing.
   bool Append(const uint8_t* data,
               size_t length,
               TimeDelta append_window_start,
               TimeDelta append_window_end,
-              TimeDelta* timestamp_offset,
-              const InitSegmentReceivedCB& init_segment_received_cb);
+              TimeDelta* timestamp_offset);
 
   // Aborts the current append sequence and resets the parser.
   void ResetParserState(TimeDelta append_window_start,
                         TimeDelta append_window_end,
                         TimeDelta* timestamp_offset);
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
@@ skipping 37 matching lines @@
   // |memory_limit| is the maximum number of bytes each stream of type |type|
   // is allowed to hold in its buffer.
   void SetMemoryLimits(DemuxerStream::Type type, size_t memory_limit);
   bool IsSeekWaitingForData() const;
 
   typedef std::list<Ranges<TimeDelta>> RangesList;
   static Ranges<TimeDelta> ComputeRangesIntersection(
       const RangesList& activeRanges,
       bool ended);
 
+  void SetTracksWatcher(const Demuxer::MediaTracksUpdatedCB& tracks_updated_cb);

[wolenetz, 2016/03/05 01:47:43]

nit: document what this means; when it should be called, and when the callback
will be called.

[servolk, 2016/03/05 01:56:19]

Will do, but at this point there are three other CLs that are based on this one.
So to avoid too much rebasing, I'll add a comment in separate CL.

+
  private:
   // Called by the |stream_parser_| when a new initialization segment is
   // encountered.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing decoder configurations.
   bool OnNewConfigs(bool allow_audio,
                     bool allow_video,
                     scoped_ptr<MediaTracks> tracks,
                     const StreamParser::TextTrackConfigMap& text_configs);
 
@@ skipping 58 matching lines @@
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
   TextStreamMap text_stream_map_;  // |this| owns the map's stream pointers.
 
   scoped_ptr<FrameProcessor> frame_processor_;
   scoped_refptr<MediaLog> media_log_;
   StreamParser::InitCB init_cb_;
 
   // During Append(), OnNewConfigs() will trigger the initialization segment
-  // received algorithm. This callback is only non-NULL during the lifetime of
-  // an Append() call. Note, the MSE spec explicitly disallows this algorithm
+  // received algorithm. Note, the MSE spec explicitly disallows this algorithm
   // during an Abort(), since Abort() is allowed only to emit coded frames, and
-  // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment).
-  InitSegmentReceivedCB init_segment_received_cb_;
+  // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment). So we
+  // also have a flag here that indicates if Append is in progress and we can
+  // invoke this callback.
+  Demuxer::MediaTracksUpdatedCB init_segment_received_cb_;
+  bool append_in_progress_ = false;

[wolenetz, 2016/03/05 01:47:43]

this flag and associated comment and usage seem unnecessary. the previous
comment was there simply because the value of the member callback variable could
only be trusted during an append. so long as we only call it during
append-related processing, we need no such flag.

[servolk, 2016/03/05 01:56:19]

Done.

 
   // Indicates that timestampOffset should be updated automatically during
   // OnNewBuffers() based on the earliest end timestamp of the buffers provided.
   // TODO(wolenetz): Refactor this function while integrating April 29, 2014
   // changes to MSE spec. See http://crbug.com/371499.
   bool auto_update_timestamp_offset_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaSourceState);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_MEDIA_SOURCE_STATE_H_