MediaRecorder: remove ASSERTS in bitrate clamping.

third_party/WebKit/Source/modules/mediarecorder/MediaRecorder.cpp

 // 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 "modules/mediarecorder/MediaRecorder.h"
 
 #include "bindings/core/v8/Dictionary.h"
 #include "core/events/Event.h"
 #include "core/fileapi/Blob.h"
 #include "core/inspector/ConsoleMessage.h"
@@ skipping 34 matching lines @@
 
 // Allocates the requested bit rates from |bitrateOptions| into the respective
 // |{audio,video}BitsPerSecond| (where a value of zero indicates Platform to use
 // whatever it sees fit). If |options.bitsPerSecond()| is specified, it
 // overrides any specific bitrate, and the UA is free to allocate as desired:
 // here a 90%/10% video/audio is used. In all cases where a value is explicited
 // or calculated, values are clamped in sane ranges.
 // This method throws NotSupportedError.
 void AllocateVideoAndAudioBitrates(ExceptionState& exceptionState, ExecutionContext* context, const MediaRecorderOptions& options, MediaStream* stream, int* audioBitsPerSecond, int* videoBitsPerSecond)
 {
+    const bool useVideo = !stream->getVideoTracks().isEmpty();
+    const bool useAudio = !stream->getAudioTracks().isEmpty();
+
     // Clamp incoming values into a signed integer's range.
     // TODO(mcasas): This section would no be needed if the bit rates are signed or double, see https://github.com/w3c/mediacapture-record/issues/48.
     const unsigned kMaxIntAsUnsigned = std::numeric_limits<int>::max();
 
-    ASSERT(options.bitsPerSecond() >= 0);
-    ASSERT(options.bitsPerSecond() < kMaxIntAsUnsigned);
-    const int overallBps = std::min(options.bitsPerSecond(), kMaxIntAsUnsigned);
-
-    // If options.hasBitsPerSecond() is not present, assert than the individual |{video,audio}BitsPerSecond| are smaller than the maximum.
-    ASSERT(!options.hasBitsPerSecond() || options.videoBitsPerSecond() < kMaxIntAsUnsigned);
-    int videoBps = std::min(options.videoBitsPerSecond(), kMaxIntAsUnsigned);
-
-    ASSERT(!options.hasBitsPerSecond() || options.audioBitsPerSecond() < kMaxIntAsUnsigned);
-    int audioBps = std::min(options.audioBitsPerSecond(), kMaxIntAsUnsigned);
-
-    const bool useVideo = !stream->getVideoTracks().isEmpty();
-    const bool useAudio = !stream->getAudioTracks().isEmpty();
+    int overallBps = 0;
+    if (options.hasBitsPerSecond())
+        overallBps = std::min(options.bitsPerSecond(), kMaxIntAsUnsigned);
+    int videoBps = 0;
+    if (options.hasVideoBitsPerSecond() && useVideo)
+        videoBps = std::min(options.videoBitsPerSecond(), kMaxIntAsUnsigned);
+    int audioBps = 0;
+    if (options.hasAudioBitsPerSecond() && useAudio)
+        audioBps = std::min(options.audioBitsPerSecond(), kMaxIntAsUnsigned);
 
     if (useAudio) {
         // |overallBps| overrides the specific audio and video bit rates.
-        if (overallBps) {
+        if (options.hasBitsPerSecond()) {
             if (useVideo)
                 audioBps = overallBps / 10;
             else
                 audioBps = overallBps;
         }
         // Limit audio bitrate values if set explicitly or calculated.
-        if (audioBps) {
+        if (options.hasAudioBitsPerSecond() || options.hasBitsPerSecond()) {
             if (audioBps > kLargestAutoAllocatedOpusBitRate) {
                 context->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, "Clamping calculated audio bitrate (" + String::number(audioBps) + "bps) to the maximum (" + String::number(kLargestAutoAllocatedOpusBitRate) + "bps)"));
                 audioBps = kLargestAutoAllocatedOpusBitRate;
             }
 
             if (audioBps < kSmallestPossibleOpusBitRate) {
                 context->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, "Clamping calculated audio bitrate (" + String::number(audioBps) + "bps) to the minimum (" + String::number(kSmallestPossibleOpusBitRate) + "bps)"));
                 audioBps = kSmallestPossibleOpusBitRate;
             }
+        } else {
+            ASSERT(!audioBps);
         }
-    } else {
-        audioBps = 0;
     }
+
     if (useVideo) {
         // Allocate the remaining |overallBps|, if any, to video.
-        if (overallBps)
+        if (options.hasBitsPerSecond())
             videoBps = overallBps - audioBps;
-        // Clamp the video bit rate if the user has set it explicitly or has used the overall bitrate.
-        if ((options.videoBitsPerSecond() > 0 || overallBps > 0) && (videoBps < kSmallestPossibleVpxBitRate)) {
-            context->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, "Clamping calculated video bitrate (" + String::number(videoBps) + "bps) to the minimum (" + String::number(kSmallestPossibleVpxBitRate) + "bps)"));
-            videoBps = kSmallestPossibleVpxBitRate;
+        // Clamp the video bit rate. Avoid clamping if the user has not set it explicitly.
+        if (options.hasVideoBitsPerSecond() || options.hasBitsPerSecond()) {
+            if (videoBps < kSmallestPossibleVpxBitRate) {
+                context->addConsoleMessage(ConsoleMessage::create(JSMessageSource, WarningMessageLevel, "Clamping calculated video bitrate (" + String::number(videoBps) + "bps) to the minimum (" + String::number(kSmallestPossibleVpxBitRate) + "bps)"));
+                videoBps = kSmallestPossibleVpxBitRate;
+            }
+        } else {
+            ASSERT(!videoBps);
         }
-    } else {
-        videoBps = 0;
     }
 
     *videoBitsPerSecond = videoBps;
     *audioBitsPerSecond = audioBps;
     return;
 }
 
 } // namespace
 
 MediaRecorder* MediaRecorder::create(ExecutionContext* context, MediaStream* stream, ExceptionState& exceptionState)
@@ skipping 232 matching lines @@
 DEFINE_TRACE(MediaRecorder)
 {
     visitor->trace(m_stream);
     visitor->trace(m_dispatchScheduledEventRunner);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<MediaRecorder>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink