Replace ASSERT(false) by RTC_NOTREACHED().

webrtc/base/httpbase.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <memory>
 
 #if defined(WEBRTC_WIN)
 #include "webrtc/base/win32.h"
 #else  // !WEBRTC_WIN
 #define SEC_E_CERT_EXPIRED (-2146893016)
 #endif  // !WEBRTC_WIN
 
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/httpbase.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/socket.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
 
 namespace rtc {
 
 //////////////////////////////////////////////////////////////////////
@@ skipping 28 matching lines @@
   data_size_ = SIZE_UNKNOWN;
 }
 
 HttpParser::ProcessResult
 HttpParser::Process(const char* buffer, size_t len, size_t* processed,
                     HttpError* error) {
   *processed = 0;
   *error = HE_NONE;
 
   if (state_ >= ST_COMPLETE) {
-    ASSERT(false);
+    RTC_NOTREACHED();
     return PR_COMPLETE;
   }
 
   while (true) {
     if (state_ < ST_DATA) {
       size_t pos = *processed;
       while ((pos < len) && (buffer[pos] != '\n')) {
         pos += 1;
       }
       if (pos >= len) {
@@ skipping 121 matching lines @@
     break;
 
   case ST_TRAILERS:
     if (len == 0) {
       return PR_COMPLETE;
     }
     // *error = onHttpRecvTrailer();
     break;
 
   default:
-    ASSERT(false);
+    RTC_NOTREACHED();
     break;
   }
 
   return PR_CONTINUE;
 }
 
 bool
 HttpParser::is_valid_end_of_input() const {
   return (state_ == ST_DATA) && (data_size_ == SIZE_UNKNOWN);
 }
@@ skipping 149 matching lines @@
 }
 
 bool
 HttpBase::isConnected() const {
   return (http_stream_ != NULL) && (http_stream_->GetState() == SS_OPEN);
 }
 
 bool
 HttpBase::attach(StreamInterface* stream) {
   if ((mode_ != HM_NONE) || (http_stream_ != NULL) || (stream == NULL)) {
-    ASSERT(false);
+    RTC_NOTREACHED();
     return false;
   }
   http_stream_ = stream;
   http_stream_->SignalEvent.connect(this, &HttpBase::OnHttpStreamEvent);
   mode_ = (http_stream_->GetState() == SS_OPENING) ? HM_CONNECT : HM_NONE;
   return true;
 }
 
 StreamInterface*
 HttpBase::detach() {
@@ skipping 305 matching lines @@
         return;
       }
     } else {
       ASSERT(result == SR_ERROR);
       LOG_F(LS_ERROR) << "error";
       OnHttpStreamEvent(http_stream_, SE_CLOSE, error);
       return;
     }
   }
 
-  ASSERT(false);
+  RTC_NOTREACHED();
 }
 
 bool
 HttpBase::queue_headers() {
   ASSERT(HM_SEND == mode_);
   while (header_ != data_->end()) {
     size_t len = sprintfn(buffer_ + len_, sizeof(buffer_) - len_,
                           "%.*s: %.*s\r\n",
                           header_->first.size(), header_->first.data(),
                           header_->second.size(), header_->second.data());
@@ skipping 157 matching lines @@
   }
 }
 
 void
 HttpBase::OnComplete(HttpError err) {
   LOG_F(LS_VERBOSE);
   do_complete(err);
 }
 
 } // namespace rtc