Implement reading of media track info from WebM and MP4 containers

media/formats/webm/webm_tracks_parser.h

 // Copyright 2014 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_FORMATS_WEBM_WEBM_TRACKS_PARSER_H_
 #define MEDIA_FORMATS_WEBM_WEBM_TRACKS_PARSER_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/media_log.h"
+#include "media/base/media_tracks.h"
 #include "media/base/text_track_config.h"
 #include "media/base/video_decoder_config.h"
 #include "media/formats/webm/webm_audio_client.h"
 #include "media/formats/webm/webm_content_encodings_client.h"
 #include "media/formats/webm/webm_parser.h"
 #include "media/formats/webm/webm_video_client.h"
 
 namespace media {
 
 // Parser for WebM Tracks element.
@@ skipping 39 matching lines @@
   const VideoDecoderConfig& video_decoder_config() {
     return video_decoder_config_;
   }
 
   typedef std::map<int, TextTrackConfig> TextTracks;
 
   const TextTracks& text_tracks() const {
     return text_tracks_;
   }
 
+  scoped_ptr<MediaTracks> media_tracks() { return std::move(media_tracks_); }

[wolenetz, 2016/03/05 03:26:21]

nit: Using std::move here may have unintended consequence especially if not
documented. What is expected if media_tracks() is called twice in a row, for
instance?

[servolk, 2016/03/07 23:45:02]

Well, I agree that it's not super pretty solution, but on the other hand the
fact that this returns scoped_ptr already gives you an indication that you are
being given ownership of this object. So I thought it was ok to do this for now,
to unblock further work.

[wolenetz, 2016/03/10 19:53:29]

I understand. Please then document in the .h for this method that at most one
call to it is supported. Even better, enforce that with some boolean + a DCHECK
gating that at most one call can happen.
Alternatively, is this a place where scoped_refptr might be better, so that this
parser isn't so tightly bound to its caller only calling this method once?

[servolk, 2016/03/10 22:25:38]

Done.
Note that this method is in the WebMTracksParser class, which is probably only
going to be ever used directly in WebMStreamParser + unit tests (since this
class is too low-level to be useful on it's own, unlike WebMStreamParser). So it
doesn't seem like a big deal to me. We could probably try to use scoped_refptr,
but then we'd have to make MediaTracks refcounted and update all other places
that use it. I don't see a lot of benefit in doing that atm. But of course, we
can always reconsider in the future.

+
  private:
   // WebMParserClient implementation.
   WebMParserClient* OnListStart(int id) override;
   bool OnListEnd(int id) override;
   bool OnUInt(int id, int64_t val) override;
   bool OnFloat(int id, double val) override;
   bool OnBinary(int id, const uint8_t* data, int size) override;
   bool OnString(int id, const std::string& str) override;
 
   int64_t track_type_;
@@ skipping 17 matching lines @@
   std::string audio_encryption_key_id_;
   std::string video_encryption_key_id_;
   scoped_refptr<MediaLog> media_log_;
 
   WebMAudioClient audio_client_;
   AudioDecoderConfig audio_decoder_config_;
 
   WebMVideoClient video_client_;
   VideoDecoderConfig video_decoder_config_;
 
+  scoped_ptr<MediaTracks> media_tracks_;
+
   DISALLOW_COPY_AND_ASSIGN(WebMTracksParser);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FORMATS_WEBM_WEBM_TRACKS_PARSER_H_