Basic media tracks implementation for media stream parsers

This CL adds basic media::MediaTrack implementation, media::MediaTracks
collection that associates media tracks with audio/video configs, and
makes necessary changes in MSE stream parsers to pass around the
MediaTracks collection instead of individual audio/video configs.

BUG=249427, 249428

Review URL: https://codereview.chromium.org/1716503002

Cr-Commit-Position: refs/heads/master@{#378583}

media/base/BUILD.gn

@@ -135,6 +135,10 @@ source_set("base") {
     "media_resources.h",
     "media_switches.cc",
     "media_switches.h",
+    "media_track.cc",
+    "media_track.h",
+    "media_tracks.cc",
+    "media_tracks.h",
     "media_util.cc",
     "media_util.h",
     "mime_util.cc",

media/base/media_track.cc

@@ -0,0 +1,18 @@
+// Copyright 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.
+
+#include "media/base/media_track.h"
+
+namespace media {
+
+MediaTrack::MediaTrack(Type type,
+                       const std::string& id,
+                       const std::string& kind,
+                       const std::string& label,
+                       const std::string& lang)
+    : type_(type), id_(id), kind_(kind), label_(label), language_(lang) {}
+
+MediaTrack::~MediaTrack() {}
+
+}  // namespace media

media/base/media_track.h

@@ -0,0 +1,41 @@
+// Copyright 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_BASE_MEDIA_TRACK_H_
+#define MEDIA_BASE_MEDIA_TRACK_H_
+
+#include <string>
+
+#include "media/base/media_export.h"
+
+namespace media {
+
+class MEDIA_EXPORT MediaTrack {
+ public:
+  enum Type { Text, Audio, Video };
+  MediaTrack(Type type,
+             const std::string& id,
+             const std::string& kind,
+             const std::string& label,
+             const std::string& lang);
+  ~MediaTrack();
+
+  Type type() const { return type_; }
+
+  const std::string& id() const { return id_; }
+  const std::string& kind() const { return kind_; }
+  const std::string& label() const { return label_; }
+  const std::string& language() const { return language_; }
+
+ private:
+  Type type_;
+  std::string id_;
+  std::string kind_;
+  std::string label_;
+  std::string language_;
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MEDIA_TRACK_H_

media/base/media_tracks.cc

@@ -0,0 +1,81 @@
+// Copyright 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.
+
+#include "media/base/media_tracks.h"
+
+#include "base/bind.h"
+#include "media/base/audio_decoder_config.h"
+#include "media/base/video_decoder_config.h"
+
+namespace media {
+
+MediaTracks::MediaTracks() {}
+
+MediaTracks::~MediaTracks() {}
+
+void MediaTracks::AddAudioTrack(const AudioDecoderConfig& config,
+                                const std::string& id,
+                                const std::string& kind,
+                                const std::string& label,
+                                const std::string& language) {
+  DCHECK(config.IsValidConfig());
+  CHECK(audio_configs_.find(id) == audio_configs_.end());
+  scoped_ptr<MediaTrack> track = make_scoped_ptr(
+      new MediaTrack(MediaTrack::Audio, id, kind, label, language));
+  tracks_.push_back(std::move(track));
+  audio_configs_[id] = config;
+}
+
+void MediaTracks::AddVideoTrack(const VideoDecoderConfig& config,
+                                const std::string& id,
+                                const std::string& kind,
+                                const std::string& label,
+                                const std::string& language) {
+  DCHECK(config.IsValidConfig());
+  CHECK(video_configs_.find(id) == video_configs_.end());
+  scoped_ptr<MediaTrack> track = make_scoped_ptr(
+      new MediaTrack(MediaTrack::Video, id, kind, label, language));
+  tracks_.push_back(std::move(track));
+  video_configs_[id] = config;
+}
+
+const AudioDecoderConfig& MediaTracks::getAudioConfig(
+    const std::string& id) const {
+  auto it = audio_configs_.find(id);
+  if (it != audio_configs_.end())
+    return it->second;
+  static AudioDecoderConfig invalidConfig;
+  return invalidConfig;
+}
+
+const VideoDecoderConfig& MediaTracks::getVideoConfig(
+    const std::string& id) const {
+  auto it = video_configs_.find(id);
+  if (it != video_configs_.end())
+    return it->second;
+  static VideoDecoderConfig invalidConfig;
+  return invalidConfig;
+}
+
+const AudioDecoderConfig& MediaTracks::getFirstAudioConfig() const {
+  for (const auto& track : tracks()) {
+    if (track->type() == MediaTrack::Audio) {
+      return getAudioConfig(track->id());
+    }
+  }
+  static AudioDecoderConfig invalidConfig;
+  return invalidConfig;
+}
+
+const VideoDecoderConfig& MediaTracks::getFirstVideoConfig() const {
+  for (const auto& track : tracks()) {
+    if (track->type() == MediaTrack::Video) {
+      return getVideoConfig(track->id());
+    }
+  }
+  static VideoDecoderConfig invalidConfig;
+  return invalidConfig;
+}
+
+}  // namespace media

media/base/media_tracks.h

@@ -0,0 +1,62 @@
+// Copyright 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_BASE_MEDIA_TRACKS_H_
+#define MEDIA_BASE_MEDIA_TRACKS_H_
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "media/base/media_export.h"
+#include "media/base/media_track.h"
+
+namespace media {
+
+class AudioDecoderConfig;
+class VideoDecoderConfig;
+
+class MEDIA_EXPORT MediaTracks {
+ public:
+  typedef std::vector<scoped_ptr<MediaTrack>> MediaTracksCollection;
+
+  MediaTracks();
+  ~MediaTracks();
+
+  // Callers need to ensure that track id is unique.
+  void AddAudioTrack(const AudioDecoderConfig& config,
+                     const std::string& id,
+                     const std::string& kind,
+                     const std::string& label,
+                     const std::string& language);
+  // Callers need to ensure that track id is unique.
+  void AddVideoTrack(const VideoDecoderConfig& config,
+                     const std::string& id,
+                     const std::string& kind,
+                     const std::string& label,
+                     const std::string& language);
+
+  const MediaTracksCollection& tracks() const { return tracks_; }
+
+  const AudioDecoderConfig& getAudioConfig(const std::string& id) const;
+  const VideoDecoderConfig& getVideoConfig(const std::string& id) const;
+
+  // TODO(servolk): These are temporary helpers useful until all code paths are
+  // converted to properly handle multiple media tracks.
+  const AudioDecoderConfig& getFirstAudioConfig() const;
+  const VideoDecoderConfig& getFirstVideoConfig() const;
+
+ private:
+  MediaTracksCollection tracks_;
+  std::map<std::string, AudioDecoderConfig> audio_configs_;
+  std::map<std::string, VideoDecoderConfig> video_configs_;
+
+  DISALLOW_COPY_AND_ASSIGN(MediaTracks);
+};
+
+}  // namespace media
+
+#endif  // MEDIA_BASE_MEDIA_TRACKS_H_

media/base/stream_parser.h

@@ -25,10 +25,9 @@
 
 namespace media {
 
-class AudioDecoderConfig;
+class MediaTracks;
 class StreamParserBuffer;
 class TextTrackConfig;
-class VideoDecoderConfig;
 
 // Abstract interface for parsing media byte streams.
 class MEDIA_EXPORT StreamParser {
@@ -76,18 +75,17 @@ class MEDIA_EXPORT StreamParser {
   typedef base::Callback<void(const InitParameters& params)> InitCB;
 
   // Indicates when new stream configurations have been parsed.
-  // First parameter - The new audio configuration. If the config is not valid
-  //                   then it means that there isn't an audio stream.
-  // Second parameter - The new video configuration. If the config is not valid
-  //                    then it means that there isn't an audio stream.
-  // Third parameter - The new text tracks configuration.  If the map is empty,
-  //                   then no text tracks were parsed from the stream.
+  // First parameter - An object containing information about media tracks as
+  //                   well as audio/video decoder configs associated with each
+  //                   track.
+  // Second parameter - The new text tracks configuration.  If the map is empty,
+  //                    then no text tracks were parsed from the stream.
   // Return value - True if the new configurations are accepted.
   //                False if the new configurations are not supported
   //                and indicates that a parsing error should be signalled.
-  typedef base::Callback<bool(const AudioDecoderConfig&,
-                              const VideoDecoderConfig&,
-                              const TextTrackConfigMap&)> NewConfigCB;
+  typedef base::Callback<bool(scoped_ptr<MediaTracks>,
+                              const TextTrackConfigMap&)>
+      NewConfigCB;
 
   // New stream buffers have been parsed.
   // First parameter - A queue of newly parsed audio buffers.

media/blink/websourcebuffer_impl.cc

@@ -12,6 +12,7 @@
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
+#include "media/base/media_tracks.h"
 #include "media/base/timestamp_constants.h"
 #include "media/filters/chunk_demuxer.h"
 #include "third_party/WebKit/public/platform/WebSourceBufferClient.h"
@@ -158,8 +159,10 @@ void WebSourceBufferImpl::removedFromMediaSource() {
   client_ = NULL;
 }
 
-void WebSourceBufferImpl::InitSegmentReceived() {
+void WebSourceBufferImpl::InitSegmentReceived(const MediaTracks& tracks) {
   DVLOG(1) << __FUNCTION__;
+  // TODO(servolk): Implement passing MediaTrack info to blink level.
+  // https://crbug.com/249428
   client_->initializationSegmentReceived();
 }
 

media/blink/websourcebuffer_impl.h

@@ -16,6 +16,7 @@
 
 namespace media {
 class ChunkDemuxer;
+class MediaTracks;
 
 class WebSourceBufferImpl : public blink::WebSourceBuffer {
  public:
@@ -42,7 +43,7 @@ class WebSourceBufferImpl : public blink::WebSourceBuffer {
  private:
   // Demuxer callback handler to process an initialization segment received
   // during an append() call.
-  void InitSegmentReceived();
+  void InitSegmentReceived(const MediaTracks& tracks);
 
   std::string id_;
   ChunkDemuxer* demuxer_;  // Owned by WebMediaPlayerImpl.