MediaRecorder: wire the bitRate settings in Blink and content (2nd go)

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 14 matching lines @@
 #include "media/capture/webm_muxer.h"
 #include "third_party/WebKit/public/platform/WebMediaRecorderHandlerClient.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace content {
 
 MediaRecorderHandler::MediaRecorderHandler()
-    : use_vp9_(false),
+    : video_bits_per_second_(0),
+      audio_bits_per_second_(0),
+      use_vp9_(false),
       recording_(false),
       client_(nullptr),
       weak_factory_(this) {}
 
 MediaRecorderHandler::~MediaRecorderHandler() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Send a |last_in_slice| to our |client_|.
   if (client_)
     client_->writeData(nullptr, 0u, true);
 }
@@ skipping 31 matching lines @@
     if (found == &codecs[codecs_count])
       return false;
   }
   return true;
 }
 
 bool MediaRecorderHandler::initialize(
     blink::WebMediaRecorderHandlerClient* client,
     const blink::WebMediaStream& media_stream,
     const blink::WebString& type,
-    const blink::WebString& codecs) {
+    const blink::WebString& codecs,
+    int32_t audio_bits_per_second,
+    int32_t video_bits_per_second) {
   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;
 
+  audio_bits_per_second_ = audio_bits_per_second;
+  video_bits_per_second_ = video_bits_per_second;
   return true;
 }
 
 bool MediaRecorderHandler::start() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   DCHECK(!recording_);
   return start(0);
 }
 
 bool MediaRecorderHandler::start(int timeslice) {
@@ skipping 32 matching lines @@
         << "Recording multiple video tracks is not implemented. "
         << "Only recording first video track.";
     const blink::WebMediaStreamTrack& video_track = video_tracks[0];
     if (video_track.isNull())
       return false;
 
     const VideoTrackRecorder::OnEncodedVideoCB on_encoded_video_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedVideo, weak_factory_.GetWeakPtr()));
 
-    video_recorders_.push_back(
-        new VideoTrackRecorder(use_vp9_, video_track, on_encoded_video_cb));
+    video_recorders_.push_back(new VideoTrackRecorder(
+        use_vp9_, video_track, on_encoded_video_cb, video_bits_per_second_));
   }
 
   if (use_audio_tracks) {
     // TODO(ajose): The muxer API supports only one audio track. Extend it to
     // several tracks.
     LOG_IF(WARNING, audio_tracks.size() > 1u)
         << "Recording multiple audio"
         << " tracks is not implemented.  Only recording first audio track.";
     const blink::WebMediaStreamTrack& audio_track = audio_tracks[0];
     if (audio_track.isNull())
       return false;
 
     const AudioTrackRecorder::OnEncodedAudioCB on_encoded_audio_cb =
         media::BindToCurrentLoop(base::Bind(
             &MediaRecorderHandler::OnEncodedAudio, weak_factory_.GetWeakPtr()));
 
-    audio_recorders_.push_back(
-        new AudioTrackRecorder(audio_track, on_encoded_audio_cb));
+    audio_recorders_.push_back(new AudioTrackRecorder(
+        audio_track, on_encoded_audio_cb, audio_bits_per_second_));
   }
 
   recording_ = true;
   return true;
 }
 
 void MediaRecorderHandler::stop() {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   // Don't check |recording_| since we can go directly from pause() to stop().
 
@@ skipping 35 matching lines @@
 void MediaRecorderHandler::OnEncodedAudio(const media::AudioParameters& params,
                                           scoped_ptr<std::string> encoded_data,
                                           base::TimeTicks timestamp) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
   if (webm_muxer_)
     webm_muxer_->OnEncodedAudio(params, std::move(encoded_data), timestamp);
 }
 
 void MediaRecorderHandler::WriteData(base::StringPiece data) {
   DCHECK(main_render_thread_checker_.CalledOnValidThread());
-
   // Non-buffered mode does not need to check timestamps.
   if (timeslice_.is_zero()) {
     client_->writeData(data.data(), data.length(), true  /* lastInSlice */);
     return;
   }
 
   const TimeTicks now = TimeTicks::Now();
   const bool last_in_slice = now > slice_origin_timestamp_ + timeslice_;
   DVLOG_IF(1, last_in_slice) << "Slice finished @ " << now;
   if (last_in_slice)
@@ skipping 15 matching lines @@
     recorder->OnData(audio_bus, timestamp);
 }
 
 void MediaRecorderHandler::SetAudioFormatForTesting(
     const media::AudioParameters& params) {
   for (auto* recorder : audio_recorders_)
     recorder->OnSetFormat(params);
 }
 
 }  // namespace content