WebKit MediaStream cleanup: ASSERT-->DCHECK and ASSERT_NOT_REACHED-->NOTREACHED etc

third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 88 matching lines @@
     if (state == RTCPeerConnection::SignalingStateClosed) {
         exceptionState.throwDOMException(InvalidStateError, kSignalingStateClosedMessage);
         return true;
     }
 
     return false;
 }
 
 void asyncCallErrorCallback(RTCPeerConnectionErrorCallback* errorCallback, DOMException* exception)
 {
-    ASSERT(errorCallback);
+    DCHECK(errorCallback);
     Microtask::enqueueMicrotask(bind(&RTCPeerConnectionErrorCallback::handleEvent, errorCallback, exception));
 }
 
 bool callErrorCallbackIfSignalingStateClosed(RTCPeerConnection::SignalingState state, RTCPeerConnectionErrorCallback* errorCallback)
 {
     if (state == RTCPeerConnection::SignalingStateClosed) {
         if (errorCallback)
             asyncCallErrorCallback(errorCallback, DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
         return true;
     }
 
     return false;
 }
 
 bool isIceCandidateMissingSdp(const RTCIceCandidateInitOrRTCIceCandidate& candidate)
 {
     if (candidate.isRTCIceCandidateInit()) {
         const RTCIceCandidateInit& iceCandidateInit = candidate.getAsRTCIceCandidateInit();
         return !iceCandidateInit.hasSdpMid() && !iceCandidateInit.hasSdpMLineIndex();
     }
 
-    ASSERT(candidate.isRTCIceCandidate());
+    DCHECK(candidate.isRTCIceCandidate());
     return false;
 }
 
 WebRTCOfferOptions convertToWebRTCOfferOptions(const RTCOfferOptions& options)
 {
     return WebRTCOfferOptions(RTCOfferOptionsPlatform::create(
         -1, -1,
         options.hasVoiceActivityDetection() ? options.voiceActivityDetection() : true,
         options.hasIceRestart() ? options.iceRestart() : false));
 }
 
 WebRTCAnswerOptions convertToWebRTCAnswerOptions(const RTCAnswerOptions& options)
 {
     return WebRTCAnswerOptions(RTCAnswerOptionsPlatform::create(
         options.hasVoiceActivityDetection() ? options.voiceActivityDetection() : true));
 }
 
 WebRTCICECandidate convertToWebRTCIceCandidate(const RTCIceCandidateInitOrRTCIceCandidate& candidate)
 {
     if (candidate.isRTCIceCandidateInit()) {
         const RTCIceCandidateInit& iceCandidateInit = candidate.getAsRTCIceCandidateInit();
         return WebRTCICECandidate(iceCandidateInit.candidate(), iceCandidateInit.sdpMid(), iceCandidateInit.sdpMLineIndex());
     }
 
-    ASSERT(candidate.isRTCIceCandidate());
+    DCHECK(candidate.isRTCIceCandidate());
     return candidate.getAsRTCIceCandidate()->webCandidate();
 }
 
 // Helper class for RTCPeerConnection::generateCertificate.
 class WebRTCCertificateObserver : public WebRTCCertificateCallback {
 public:
     // Takes ownership of |resolver|.
     static WebRTCCertificateObserver* create(ScriptPromiseResolver* resolver)
     {
         return new WebRTCCertificateObserver(resolver);
@@ skipping 270 matching lines @@
         m_stopped = true;
         exceptionState.throwDOMException(NotSupportedError, "Failed to initialize native PeerConnection.");
         return;
     }
 }
 
 RTCPeerConnection::~RTCPeerConnection()
 {
     // This checks that close() or stop() is called before the destructor.
     // We are assuming that a wrapper is always created when RTCPeerConnection is created.
-    ASSERT(m_closed || m_stopped);
+    DCHECK(m_closed || m_stopped);
 }
 
 ScriptPromise RTCPeerConnection::createOffer(ScriptState* scriptState, const RTCOfferOptions& options)
 {
     if (m_signalingState == SignalingStateClosed)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(InvalidStateError, kSignalingStateClosedMessage));
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestPromiseImpl::create(this, resolver);
     m_peerHandler->createOffer(request, convertToWebRTCOfferOptions(options));
     return promise;
 }
 
 ScriptPromise RTCPeerConnection::createOffer(ScriptState* scriptState, RTCSessionDescriptionCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback, const Dictionary& rtcOfferOptions)
 {
-    ASSERT(successCallback);
-    ASSERT(errorCallback);
+    DCHECK(successCallback);
+    DCHECK(errorCallback);
     ExecutionContext* context = scriptState->getExecutionContext();
     UseCounter::count(context, UseCounter::RTCPeerConnectionCreateOfferLegacyFailureCallback);
     if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
         return ScriptPromise::castUndefined(scriptState);
 
     RTCOfferOptionsPlatform* offerOptions = parseOfferOptions(rtcOfferOptions);
     RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestImpl::create(getExecutionContext(), this, successCallback, errorCallback);
 
     if (offerOptions) {
         if (offerOptions->offerToReceiveAudio() != -1 || offerOptions->offerToReceiveVideo() != -1)
@@ skipping 31 matching lines @@
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     RTCSessionDescriptionRequest* request = RTCSessionDescriptionRequestPromiseImpl::create(this, resolver);
     m_peerHandler->createAnswer(request, convertToWebRTCAnswerOptions(options));
     return promise;
 }
 
 ScriptPromise RTCPeerConnection::createAnswer(ScriptState* scriptState, RTCSessionDescriptionCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback, const Dictionary& mediaConstraints)
 {
-    ASSERT(successCallback);
-    ASSERT(errorCallback);
+    DCHECK(successCallback);
+    DCHECK(errorCallback);
     ExecutionContext* context = scriptState->getExecutionContext();
     UseCounter::count(context, UseCounter::RTCPeerConnectionCreateAnswerLegacyFailureCallback);
     if (mediaConstraints.isObject())
         UseCounter::count(context, UseCounter::RTCPeerConnectionCreateAnswerLegacyConstraints);
     else
         UseCounter::count(context, UseCounter::RTCPeerConnectionCreateAnswerLegacyCompliant);
 
     if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
         return ScriptPromise::castUndefined(scriptState);
 
@@ skipping 32 matching lines @@
     } else {
         if (!successCallback)
             UseCounter::count(context, UseCounter::RTCPeerConnectionSetLocalDescriptionLegacyNoSuccessCallback);
         if (!errorCallback)
             UseCounter::count(context, UseCounter::RTCPeerConnectionSetLocalDescriptionLegacyNoFailureCallback);
     }
 
     if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
         return ScriptPromise::castUndefined(scriptState);
 
-    ASSERT(sessionDescription);
+    DCHECK(sessionDescription);
 
     RTCVoidRequest* request = RTCVoidRequestImpl::create(getExecutionContext(), this, successCallback, errorCallback);
     m_peerHandler->setLocalDescription(request, sessionDescription->webSessionDescription());
     return ScriptPromise::castUndefined(scriptState);
 }
 
 RTCSessionDescription* RTCPeerConnection::localDescription()
 {
     WebRTCSessionDescription webSessionDescription = m_peerHandler->localDescription();
     if (webSessionDescription.isNull())
@@ skipping 22 matching lines @@
     } else {
         if (!successCallback)
             UseCounter::count(context, UseCounter::RTCPeerConnectionSetRemoteDescriptionLegacyNoSuccessCallback);
         if (!errorCallback)
             UseCounter::count(context, UseCounter::RTCPeerConnectionSetRemoteDescriptionLegacyNoFailureCallback);
     }
 
     if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
         return ScriptPromise::castUndefined(scriptState);
 
-    ASSERT(sessionDescription);
+    DCHECK(sessionDescription);
 
     RTCVoidRequest* request = RTCVoidRequestImpl::create(getExecutionContext(), this, successCallback, errorCallback);
     m_peerHandler->setRemoteDescription(request, sessionDescription->webSessionDescription());
     return ScriptPromise::castUndefined(scriptState);
 }
 
 RTCSessionDescription* RTCPeerConnection::remoteDescription()
 {
     WebRTCSessionDescription webSessionDescription = m_peerHandler->remoteDescription();
     if (webSessionDescription.isNull())
@@ skipping 59 matching lines @@
         if (cryptoAlgorithm.ecKeyGenParams()->namedCurve() == WebCryptoNamedCurveP256) {
             keyParams.set(WebRTCKeyParams::createECDSA(WebRTCECCurveNistP256));
         } else {
             return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, unsupportedParamsString));
         }
         break;
     default:
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, "The 1st argument provided is an AlgorithmIdentifier, but the algorithm is not supported."));
         break;
     }
-    ASSERT(!keyParams.isNull());
+    DCHECK(!keyParams.isNull());
 
     OwnPtr<WebRTCCertificateGenerator> certificateGenerator = adoptPtr(
         Platform::current()->createRTCCertificateGenerator());
 
     // |keyParams| was successfully constructed, but does the certificate generator support these parameters?
     if (!certificateGenerator->isSupportedKeyParams(keyParams.get())) {
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(NotSupportedError, unsupportedParamsString));
     }
 
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
@@ skipping 26 matching lines @@
     WebRTCICECandidate webCandidate = convertToWebRTCIceCandidate(candidate);
     bool implemented = m_peerHandler->addICECandidate(request, webCandidate);
     if (!implemented)
         resolver->reject(DOMException::create(OperationError, "This operation could not be completed."));
 
     return promise;
 }
 
 ScriptPromise RTCPeerConnection::addIceCandidate(ScriptState* scriptState, RTCIceCandidate* iceCandidate, VoidCallback* successCallback, RTCPeerConnectionErrorCallback* errorCallback)
 {
-    ASSERT(iceCandidate);
-    ASSERT(successCallback);
-    ASSERT(errorCallback);
+    DCHECK(iceCandidate);
+    DCHECK(successCallback);
+    DCHECK(errorCallback);
 
     if (callErrorCallbackIfSignalingStateClosed(m_signalingState, errorCallback))
         return ScriptPromise::castUndefined(scriptState);
 
     RTCVoidRequest* request = RTCVoidRequestImpl::create(getExecutionContext(), this, successCallback, errorCallback);
     bool implemented = m_peerHandler->addICECandidate(request, iceCandidate->webCandidate());
     if (!implemented)
         asyncCallErrorCallback(errorCallback, DOMException::create(OperationError, "This operation could not be completed."));
 
     return ScriptPromise::castUndefined(scriptState);
 }
 
 String RTCPeerConnection::signalingState() const
 {
     switch (m_signalingState) {
     case SignalingStateStable:
         return "stable";
     case SignalingStateHaveLocalOffer:
         return "have-local-offer";
     case SignalingStateHaveRemoteOffer:
         return "have-remote-offer";
     case SignalingStateHaveLocalPrAnswer:
         return "have-local-pranswer";
     case SignalingStateHaveRemotePrAnswer:
         return "have-remote-pranswer";
     case SignalingStateClosed:
         return "closed";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 String RTCPeerConnection::iceGatheringState() const
 {
     switch (m_iceGatheringState) {
     case ICEGatheringStateNew:
         return "new";
     case ICEGatheringStateGathering:
         return "gathering";
     case ICEGatheringStateComplete:
         return "complete";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 String RTCPeerConnection::iceConnectionState() const
 {
     switch (m_iceConnectionState) {
     case ICEConnectionStateNew:
         return "new";
     case ICEConnectionStateChecking:
         return "checking";
     case ICEConnectionStateConnected:
         return "connected";
     case ICEConnectionStateCompleted:
         return "completed";
     case ICEConnectionStateFailed:
         return "failed";
     case ICEConnectionStateDisconnected:
         return "disconnected";
     case ICEConnectionStateClosed:
         return "closed";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 void RTCPeerConnection::addStream(ExecutionContext* context, MediaStream* stream, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     if (!stream) {
         exceptionState.throwDOMException(TypeMismatchError, ExceptionMessages::argumentNullOrIncorrectType(1, "MediaStream"));
@@ skipping 108 matching lines @@
             return true;
     }
     return false;
 }
 
 RTCDTMFSender* RTCPeerConnection::createDTMFSender(MediaStreamTrack* track, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return nullptr;
 
-    ASSERT(track);
+    DCHECK(track);
 
     if (!hasLocalStreamWithTrackId(track->id())) {
         exceptionState.throwDOMException(SyntaxError, "No local stream is available for the track provided.");
         return nullptr;
     }
 
     RTCDTMFSender* dtmfSender = RTCDTMFSender::create(getExecutionContext(), m_peerHandler.get(), track, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
     return dtmfSender;
 }
 
 void RTCPeerConnection::close(ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
 
     closeInternal();
 }
 
 void RTCPeerConnection::negotiationNeeded()
 {
-    ASSERT(!m_closed);
+    DCHECK(!m_closed);
     scheduleDispatchEvent(Event::create(EventTypeNames::negotiationneeded));
 }
 
 void RTCPeerConnection::didGenerateICECandidate(const WebRTCICECandidate& webCandidate)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
     if (webCandidate.isNull())
         scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, nullptr));
     else {
         RTCIceCandidate* iceCandidate = RTCIceCandidate::create(webCandidate);
         scheduleDispatchEvent(RTCIceCandidateEvent::create(false, false, iceCandidate));
     }
 }
 
 void RTCPeerConnection::didChangeSignalingState(SignalingState newState)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
     changeSignalingState(newState);
 }
 
 void RTCPeerConnection::didChangeICEGatheringState(ICEGatheringState newState)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
     changeIceGatheringState(newState);
 }
 
 void RTCPeerConnection::didChangeICEConnectionState(ICEConnectionState newState)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
     changeIceConnectionState(newState);
 }
 
 void RTCPeerConnection::didAddRemoteStream(const WebMediaStream& remoteStream)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
 
     if (m_signalingState == SignalingStateClosed)
         return;
 
     MediaStream* stream = MediaStream::create(getExecutionContext(), remoteStream);
     m_remoteStreams.append(stream);
 
     scheduleDispatchEvent(MediaStreamEvent::create(EventTypeNames::addstream, false, false, stream));
 }
 
 void RTCPeerConnection::didRemoveRemoteStream(const WebMediaStream& remoteStream)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
 
     MediaStreamDescriptor* streamDescriptor = remoteStream;
-    ASSERT(streamDescriptor->client());
+    DCHECK(streamDescriptor->client());
 
     MediaStream* stream = static_cast<MediaStream*>(streamDescriptor->client());
     stream->streamEnded();
 
     if (m_signalingState == SignalingStateClosed)
         return;
 
     size_t pos = m_remoteStreams.find(stream);
-    ASSERT(pos != kNotFound);
+    DCHECK(pos != kNotFound);
     m_remoteStreams.remove(pos);
 
     scheduleDispatchEvent(MediaStreamEvent::create(EventTypeNames::removestream, false, false, stream));
 }
 
 void RTCPeerConnection::didAddRemoteDataChannel(WebRTCDataChannelHandler* handler)
 {
-    ASSERT(!m_closed);
-    ASSERT(getExecutionContext()->isContextThread());
+    DCHECK(!m_closed);
+    DCHECK(getExecutionContext()->isContextThread());
 
     if (m_signalingState == SignalingStateClosed)
         return;
 
     RTCDataChannel* channel = RTCDataChannel::create(getExecutionContext(), adoptPtr(handler));
     scheduleDispatchEvent(RTCDataChannelEvent::create(EventTypeNames::datachannel, false, false, channel));
 }
 
 void RTCPeerConnection::releasePeerConnectionHandler()
 {
     stop();
 }
 
 void RTCPeerConnection::closePeerConnection()
 {
-    ASSERT(m_signalingState != RTCPeerConnection::SignalingStateClosed);
+    DCHECK(m_signalingState != RTCPeerConnection::SignalingStateClosed);
     closeInternal();
 }
 
 const AtomicString& RTCPeerConnection::interfaceName() const
 {
     return EventTargetNames::RTCPeerConnection;
 }
 
 ExecutionContext* RTCPeerConnection::getExecutionContext() const
 {
@@ skipping 49 matching lines @@
 void RTCPeerConnection::changeIceConnectionState(ICEConnectionState iceConnectionState)
 {
     if (m_iceConnectionState != ICEConnectionStateClosed) {
         scheduleDispatchEvent(Event::create(EventTypeNames::iceconnectionstatechange),
             WTF::bind(&RTCPeerConnection::setIceConnectionState, this, iceConnectionState));
     }
 }
 
 void RTCPeerConnection::closeInternal()
 {
-    ASSERT(m_signalingState != RTCPeerConnection::SignalingStateClosed);
+    DCHECK(m_signalingState != RTCPeerConnection::SignalingStateClosed);
     m_peerHandler->stop();
     m_closed = true;
 
     changeIceConnectionState(ICEConnectionStateClosed);
     changeIceGatheringState(ICEGatheringStateComplete);
     changeSignalingState(SignalingStateClosed);
 }
 
 void RTCPeerConnection::scheduleDispatchEvent(RawPtr<Event> event)
 {
@@ skipping 30 matching lines @@
 {
     visitor->trace(m_localStreams);
     visitor->trace(m_remoteStreams);
     visitor->trace(m_dispatchScheduledEventRunner);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCPeerConnection>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink