Allow muting/unmuting audio through media track API

media/base/media_tracks.h

 // 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 DemuxerStream;
 class VideoDecoderConfig;
 
 class MEDIA_EXPORT MediaTracks {
  public:
   typedef std::vector<scoped_ptr<MediaTrack>> MediaTracksCollection;
+  typedef std::map<const MediaTrack*, const DemuxerStream*>
+      TrackToDemuxStreamMap;
 
   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);
+  const MediaTrack* 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 MediaTrack* 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 TrackToDemuxStreamMap& track_to_demux_stream_map() const {
+    return track_to_demux_stream_map_;
+  }
+  void set_track_to_demux_stream_map(const TrackToDemuxStreamMap& m);

[wolenetz, 2016/04/08 23:32:31]

Hmm. Is this for testing only? It seems a bit extreme.

[servolk, 2016/04/08 23:47:20]

No. This needs to be called before reporting media tracks to the clients, so
that clients (which interact with blink) can figure out how to map
blink-assigned track ids to media tracks to DemuxerStreams.  This is currently
done in MediaSourceState::OnNewConfigs and FFmpegDemuxer::OnFindStreamInfoDone
just before MediaTrackUpdatedCB is called. But now this map has the same
lifetime as MediaTracks and therefore we are guaranteed to have no dangling
MediaTrack* pointers.

[wolenetz, 2016/04/14 20:43:39]

I see. Since MediaTracks effectively owns the map, what do you think about a
refactor of this CL to make MediaTracks have more control over how the map is
maintained? e.g. make the method that constructs the map something internal to
MediaTracks. Is that feasible? It seems a bit strange to require the user of the
API to ensure that |m| is consistent with |tracks_|, for one thing.
Alternatively, and perhaps even better, would be to make TrackToDemuxStreamMap
(perhaps named differently) be the owner of MediaTracks, and use that
TrackToDemuxStreamMap object API commonly from OnNewConfigs() and
OnFindStreamInfoDone() to centralize the map maintenance ownership. WDYT?

[servolk, 2016/04/15 02:23:24]

Ok, I've refactored this code a bit, to make it simpler for MediaTrack users.
Instead of exposing the TrackToDemuxStreamMap, we can hide it (and manipulations
with it) inside the MediaTracks class, and allow demuxers to use the shared
logic for building a map for translating blink track ids into DemuxerStream*
ptrs.

[servolk, 2016/04/15 02:32:59]

To expand a bit on this: I think we probably don't need to introduce a separate
class, since all we really need  in the demuxers is a map from blink track id to
DemuxStream*, so  we can just build the map here in MediaTracks and pass it to
demuxers to use.

+
   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_;
+  TrackToDemuxStreamMap track_to_demux_stream_map_;
   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_