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

third_party/WebKit/Source/modules/mediastream/RTCDataChannel.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
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 35 matching lines @@
     exceptionState.throwDOMException(NetworkError, "Could not send data");
 }
 
 static void throwNoBlobSupportException(ExceptionState& exceptionState)
 {
     exceptionState.throwDOMException(NotSupportedError, "Blob support not implemented yet");
 }
 
 RTCDataChannel* RTCDataChannel::create(ExecutionContext* context, PassOwnPtr<WebRTCDataChannelHandler> handler)
 {
-    ASSERT(handler);
+    DCHECK(handler);
     return new RTCDataChannel(context, handler);
 }
 
 RTCDataChannel* RTCDataChannel::create(ExecutionContext* context, WebRTCPeerConnectionHandler* peerConnectionHandler, const String& label, const WebRTCDataChannelInit& init, ExceptionState& exceptionState)
 {
     OwnPtr<WebRTCDataChannelHandler> handler = adoptPtr(peerConnectionHandler->createDataChannel(label, init));
     if (!handler) {
         exceptionState.throwDOMException(NotSupportedError, "RTCDataChannel is not supported");
         return nullptr;
     }
@@ skipping 68 matching lines @@
     case ReadyStateConnecting:
         return "connecting";
     case ReadyStateOpen:
         return "open";
     case ReadyStateClosing:
         return "closing";
     case ReadyStateClosed:
         return "closed";
     }
 
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 unsigned RTCDataChannel::bufferedAmount() const
 {
     return m_handler->bufferedAmount();
 }
 
 unsigned RTCDataChannel::bufferedAmountLowThreshold() const
 {
     return m_bufferedAmountLowThreshold;
 }
 
 void RTCDataChannel::setBufferedAmountLowThreshold(unsigned threshold)
 {
     m_bufferedAmountLowThreshold = threshold;
 }
 
 String RTCDataChannel::binaryType() const
 {
     switch (m_binaryType) {
     case BinaryTypeBlob:
         return "blob";
     case BinaryTypeArrayBuffer:
         return "arraybuffer";
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
     return String();
 }
 
 void RTCDataChannel::setBinaryType(const String& binaryType, ExceptionState& exceptionState)
 {
     if (binaryType == "blob")
         throwNoBlobSupportException(exceptionState);
     else if (binaryType == "arraybuffer")
         m_binaryType = BinaryTypeArrayBuffer;
     else
@@ skipping 86 matching lines @@
 {
     if (m_binaryType == BinaryTypeBlob) {
         // FIXME: Implement.
         return;
     }
     if (m_binaryType == BinaryTypeArrayBuffer) {
         RefPtr<DOMArrayBuffer> buffer = DOMArrayBuffer::create(data, dataLength);
         scheduleDispatchEvent(MessageEvent::create(buffer.release()));
         return;
     }
-    ASSERT_NOT_REACHED();
+    NOTREACHED();
 }
 
 void RTCDataChannel::didDetectError()
 {
     scheduleDispatchEvent(Event::create(EventTypeNames::error));
 }
 
 const AtomicString& RTCDataChannel::interfaceName() const
 {
     return EventTargetNames::RTCDataChannel;
@@ skipping 25 matching lines @@
 }
 
 DEFINE_TRACE(RTCDataChannel)
 {
     visitor->trace(m_executionContext);
     visitor->trace(m_scheduledEvents);
     RefCountedGarbageCollectedEventTargetWithInlineData<RTCDataChannel>::trace(visitor);
 }
 
 } // namespace blink