MediaRecorder: make MediaRecorderHandler a MediaStreamObserver

content/renderer/media/media_recorder_handler.cc

 // Copyright 2015 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 "content/renderer/media/media_recorder_handler.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
@@ skipping 64 matching lines @@
           return base::EqualsCaseInsensitiveASCII(codec, name);
         });
     if (found == &codecs[codecs_count])
       return false;
   }
   return true;
 }
 
 bool MediaRecorderHandler::initialize(
     blink::WebMediaRecorderHandlerClient* client,
-    const blink::WebMediaStream& media_stream,
+    const blink::WebMediaStream& web_media_stream,
     const blink::WebString& type,
     const blink::WebString& codecs) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Save histogram data so we can see how much MediaStream Recorder is used.
   // The histogram counts the number of calls to the JS API.
   UpdateWebRTCMethodCount(WEBKIT_MEDIA_STREAM_RECORDER);
 
   if (!canSupportMimeType(type, codecs)) {
     DLOG(ERROR) << "Can't support " << type.utf8()
                 << ";codecs=" << codecs.utf8();
     return false;
   }
   use_vp9_ = base::ToLowerASCII(codecs.utf8()).find("vp9") != std::string::npos;
-  media_stream_ = media_stream;
   DCHECK(client);
   client_ = client;
 
+  web_media_stream_ = web_media_stream;
+  MediaStream::GetMediaStream(web_media_stream)->AddObserver(this);
+
   return true;
 }
 
 bool MediaRecorderHandler::start() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   return start(0);
 }
 
 bool MediaRecorderHandler::start(int timeslice) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
-  DCHECK(!media_stream_.isNull());
+  DCHECK(!web_media_stream_.isNull());
   DCHECK(timeslice_.is_zero());
   DCHECK(!webm_muxer_);
 
   timeslice_ = TimeDelta::FromMilliseconds(timeslice);
   slice_origin_timestamp_ = TimeTicks::Now();
 
   blink::WebVector<blink::WebMediaStreamTrack> video_tracks, audio_tracks;
-  media_stream_.videoTracks(video_tracks);
-  media_stream_.audioTracks(audio_tracks);
+  web_media_stream_.videoTracks(video_tracks);
+  web_media_stream_.audioTracks(audio_tracks);
 
   if (video_tracks.isEmpty() && audio_tracks.isEmpty()) {
     LOG(WARNING) << __FUNCTION__ << ": no media tracks.";
     return false;
   }
 
   const bool use_audio_tracks =
       !audio_tracks.isEmpty() &&
       MediaStreamAudioTrack::GetTrack(audio_tracks[0]);
 
@@ skipping 63 matching lines @@
 }
 
 void MediaRecorderHandler::resume() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   recording_ = true;
   for (const auto& video_recorder : video_recorders_)
     video_recorder->Resume();
 }
 
+void MediaRecorderHandler::TrackAdded(const blink::WebMediaStreamTrack& track) {
+  client_->onError("Track added");
+}
+
+void MediaRecorderHandler::TrackRemoved(
+    const blink::WebMediaStreamTrack& track) {
+  client_->onError("Track removed");
+}
+
 void MediaRecorderHandler::OnEncodedVideo(
     const scoped_refptr<media::VideoFrame>& video_frame,
     scoped_ptr<std::string> encoded_data,
     TimeTicks timestamp,
     bool is_key_frame) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (!webm_muxer_)
     return;
   webm_muxer_->OnEncodedVideo(video_frame, std::move(encoded_data), timestamp,
                               is_key_frame);
@@ skipping 38 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (auto* recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content