MediaRecorder: ASSERT-->DCHECK and a tiny cleanup in CanvasCapture

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 20 matching lines @@
 {
     switch (state) {
     case MediaRecorder::State::Inactive:
         return "inactive";
     case MediaRecorder::State::Recording:
         return "recording";
     case MediaRecorder::State::Paused:
         return "paused";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 // 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.
@@ skipping 29 matching lines @@
             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);
+            DCHECK(!audioBps);
         }
     }
 
     if (useVideo) {
         // Allocate the remaining |overallBps|, if any, to video.
         if (options.hasBitsPerSecond())
             videoBps = overallBps - audioBps;
         // 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);
+            DCHECK(!videoBps);
         }
     }
 
     *videoBitsPerSecond = videoBps;
     *audioBitsPerSecond = audioBps;
     return;
 }
 
 } // namespace
 
@@ skipping 19 matching lines @@
     , m_stream(stream)
     , m_streamAmountOfTracks(stream->getTracks().size())
     , m_mimeType(options.mimeType())
     , m_stopped(true)
     , m_ignoreMutedMedia(true)
     , m_audioBitsPerSecond(0)
     , m_videoBitsPerSecond(0)
     , m_state(State::Inactive)
     , m_dispatchScheduledEventRunner(AsyncMethodRunner<MediaRecorder>::create(this, &MediaRecorder::dispatchScheduledEvent))
 {
-    ASSERT(m_stream->getTracks().size());
+    DCHECK(m_stream->getTracks().size());
 
     m_recorderHandler = adoptPtr(Platform::current()->createMediaRecorderHandler());
-    ASSERT(m_recorderHandler);
+    DCHECK(m_recorderHandler);
 
     if (!m_recorderHandler) {
         exceptionState.throwDOMException(NotSupportedError, "No MediaRecorder handler can be created.");
         return;
     }
 
     AllocateVideoAndAudioBitrates(exceptionState, context, options, stream, &m_audioBitsPerSecond, &m_videoBitsPerSecond);
 
     const ContentType contentType(m_mimeType);
     if (!m_recorderHandler->initialize(this, stream->descriptor(), contentType.type(), contentType.parameter("codecs"), m_audioBitsPerSecond, m_videoBitsPerSecond)) {
@@ skipping 156 matching lines @@
 }
 
 void MediaRecorder::createBlobEvent(Blob* blob)
 {
     // TODO(mcasas): Consider launching an Event with a TypedArray inside, see https://github.com/w3c/mediacapture-record/issues/17.
     scheduleDispatchEvent(BlobEvent::create(EventTypeNames::dataavailable, blob));
 }
 
 void MediaRecorder::stopRecording()
 {
-    ASSERT(m_state != State::Inactive);
+    DCHECK(m_state != State::Inactive);
     m_state = State::Inactive;
 
     m_recorderHandler->stop();
 
     writeData(nullptr /* data */, 0 /* length */, true /* lastInSlice */);
     scheduleDispatchEvent(Event::create(EventTypeNames::stop));
 }
 
 void MediaRecorder::scheduleDispatchEvent(RawPtr<Event> event)
 {
@@ skipping 14 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