Replace ASSERT by RTC_DCHECK in all non-test code.

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.
  */
 
@@ skipping 325 matching lines @@
       return false;
     size_t data_size = base_->GetDataRemaining();
     if (SIZE_UNKNOWN == data_size)
       return false;
     if (size)
       *size = data_size;
     return true;
   }
 
   HttpBase* Disconnect(HttpError error) {
-    ASSERT(NULL != base_);
-    ASSERT(NULL != base_->doc_stream_);
+    RTC_DCHECK(NULL != base_);
+    RTC_DCHECK(NULL != base_->doc_stream_);
     HttpBase* base = base_;
     base_->doc_stream_ = NULL;
     base_ = NULL;
     error_ = error;
     return base;
   }
 
 private:
   HttpBase* base_;
   HttpError error_;
 };
 
 //////////////////////////////////////////////////////////////////////
 // HttpBase
 //////////////////////////////////////////////////////////////////////
 
 HttpBase::HttpBase() : mode_(HM_NONE), data_(NULL), notify_(NULL),
                        http_stream_(NULL), doc_stream_(NULL) {
 }
 
 HttpBase::~HttpBase() {
-  ASSERT(HM_NONE == mode_);
+  RTC_DCHECK(HM_NONE == mode_);
 }
 
 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)) {
     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() {
-  ASSERT(HM_NONE == mode_);
+  RTC_DCHECK(HM_NONE == mode_);
   if (mode_ != HM_NONE) {
     return NULL;
   }
   StreamInterface* stream = http_stream_;
   http_stream_ = NULL;
   if (stream) {
     stream->SignalEvent.disconnect(this);
   }
   return stream;
 }
 
 void
 HttpBase::send(HttpData* data) {
-  ASSERT(HM_NONE == mode_);
+  RTC_DCHECK(HM_NONE == mode_);
   if (mode_ != HM_NONE) {
     return;
   } else if (!isConnected()) {
     OnHttpStreamEvent(http_stream_, SE_CLOSE, HE_DISCONNECTED);
     return;
   }
 
   mode_ = HM_SEND;
   data_ = data;
   len_ = 0;
@@ skipping 16 matching lines @@
   if (header_ == data_->end()) {
     // We must call this at least once, in the case where there are no headers.
     queue_headers();
   }
 
   flush_data();
 }
 
 void
 HttpBase::recv(HttpData* data) {
-  ASSERT(HM_NONE == mode_);
+  RTC_DCHECK(HM_NONE == mode_);
   if (mode_ != HM_NONE) {
     return;
   } else if (!isConnected()) {
     OnHttpStreamEvent(http_stream_, SE_CLOSE, HE_DISCONNECTED);
     return;
   }
 
   mode_ = HM_RECV;
   data_ = data;
   len_ = 0;
@@ skipping 37 matching lines @@
   } else if (error == SOCKET_EACCES) {
     return HE_AUTH;
   } else if (error == SEC_E_CERT_EXPIRED) {
     return HE_CERTIFICATE_EXPIRED;
   }
   LOG_F(LS_ERROR) << "(" << error << ")";
   return (HM_CONNECT == mode_) ? HE_CONNECT_FAILED : HE_SOCKET_ERROR;
 }
 
 bool HttpBase::DoReceiveLoop(HttpError* error) {
-  ASSERT(HM_RECV == mode_);
-  ASSERT(NULL != error);
+  RTC_DCHECK(HM_RECV == mode_);
+  RTC_DCHECK(NULL != error);
 
   // Do to the latency between receiving read notifications from
   // pseudotcpchannel, we rely on repeated calls to read in order to acheive
   // ideal throughput.  The number of reads is limited to prevent starving
   // the caller.
 
   size_t loop_count = 0;
   const size_t kMaxReadCount = 20;
   bool process_requires_more_data = false;
   do {
     // The most frequent use of this function is response to new data available
     // on http_stream_.  Therefore, we optimize by attempting to read from the
     // network first (as opposed to processing existing data first).
 
     if (len_ < sizeof(buffer_)) {
       // Attempt to buffer more data.
       size_t read;
       int read_error;
       StreamResult read_result = http_stream_->Read(buffer_ + len_,
                                                     sizeof(buffer_) - len_,
                                                     &read, &read_error);
       switch (read_result) {
       case SR_SUCCESS:
-        ASSERT(len_ + read <= sizeof(buffer_));
+        RTC_DCHECK(len_ + read <= sizeof(buffer_));
         len_ += read;
         break;
       case SR_BLOCK:
         if (process_requires_more_data) {
           // We're can't make progress until more data is available.
           return false;
         }
         // Attempt to process the data already in our buffer.
         break;
       case SR_EOS:
@@ skipping 14 matching lines @@
 
     // Process data in our buffer.  Process is not guaranteed to process all
     // the buffered data.  In particular, it will wait until a complete
     // protocol element (such as http header, or chunk size) is available,
     // before processing it in its entirety.  Also, it is valid and sometimes
     // necessary to call Process with an empty buffer, since the state machine
     // may have interrupted state transitions to complete.
     size_t processed;
     ProcessResult process_result = Process(buffer_, len_, &processed,
                                             error);
-    ASSERT(processed <= len_);
+    RTC_DCHECK(processed <= len_);
     len_ -= processed;
     memmove(buffer_, buffer_ + processed, len_);
     switch (process_result) {
     case PR_CONTINUE:
       // We need more data to make progress.
       process_requires_more_data = true;
       break;
     case PR_BLOCK:
       // We're stalled on writing the processed data.
       return false;
@@ skipping 10 matching lines @@
 void
 HttpBase::read_and_process_data() {
   HttpError error;
   if (DoReceiveLoop(&error)) {
     complete(error);
   }
 }
 
 void
 HttpBase::flush_data() {
-  ASSERT(HM_SEND == mode_);
+  RTC_DCHECK(HM_SEND == mode_);
 
   // When send_required is true, no more buffering can occur without a network
   // write.
   bool send_required = (len_ >= sizeof(buffer_));
 
   while (true) {
-    ASSERT(len_ <= sizeof(buffer_));
+    RTC_DCHECK(len_ <= sizeof(buffer_));
 
     // HTTP is inherently sensitive to round trip latency, since a frequent use
     // case is for small requests and responses to be sent back and forth, and
     // the lack of pipelining forces a single request to take a minimum of the
     // round trip time.  As a result, it is to our benefit to pack as much data
     // into each packet as possible.  Thus, we defer network writes until we've
     // buffered as much data as possible.
 
     if (!send_required && (header_ != data_->end())) {
       // First, attempt to queue more header data.
@@ skipping 17 matching lines @@
 
       if (reserve >= sizeof(buffer_)) {
         send_required = true;
       } else {
         size_t read;
         int error;
         StreamResult result = data_->document->Read(buffer_ + offset,
                                                     sizeof(buffer_) - reserve,
                                                     &read, &error);
         if (result == SR_SUCCESS) {
-          ASSERT(reserve + read <= sizeof(buffer_));
+          RTC_DCHECK(reserve + read <= sizeof(buffer_));
           if (chunk_data_) {
             // Prepend the chunk length in hex.
             // Note: sprintfn appends a null terminator, which is why we can't
             // combine it with the line terminator.
             sprintfn(buffer_ + len_, kChunkDigits + 1, "%.*x",
                      kChunkDigits, read);
             // Add line terminator to the chunk length.
             memcpy(buffer_ + len_ + kChunkDigits, "\r\n", 2);
             // Add line terminator to the end of the chunk.
             memcpy(buffer_ + offset + read, "\r\n", 2);
           }
           len_ = reserve + read;
         } else if (result == SR_BLOCK) {
           // Nothing to do but flush data to the network.
           send_required = true;
         } else if (result == SR_EOS) {
           if (chunk_data_) {
             // Append the empty chunk and empty trailers, then turn off
             // chunking.
-            ASSERT(len_ + 5 <= sizeof(buffer_));
+            RTC_DCHECK(len_ + 5 <= sizeof(buffer_));
             memcpy(buffer_ + len_, "0\r\n\r\n", 5);
             len_ += 5;
             chunk_data_ = false;
           } else if (0 == len_) {
             // No more data to read, and no more data to write.
             do_complete();
             return;
           }
           // Although we are done reading data, there is still data which needs
           // to be flushed to the network.
@@ skipping 12 matching lines @@
         // If there is no source document, that means we're done.
         do_complete();
       }
       return;
     }
 
     size_t written;
     int error;
     StreamResult result = http_stream_->Write(buffer_, len_, &written, &error);
     if (result == SR_SUCCESS) {
-      ASSERT(written <= len_);
+      RTC_DCHECK(written <= len_);
       len_ -= written;
       memmove(buffer_, buffer_ + written, len_);
       send_required = false;
     } else if (result == SR_BLOCK) {
       if (send_required) {
         // Nothing more we can do until network is writeable.
         return;
       }
     } else {
-      ASSERT(result == SR_ERROR);
+      RTC_DCHECK(result == SR_ERROR);
       LOG_F(LS_ERROR) << "error";
       OnHttpStreamEvent(http_stream_, SE_CLOSE, error);
       return;
     }
   }
 
   RTC_NOTREACHED();
 }
 
 bool
 HttpBase::queue_headers() {
-  ASSERT(HM_SEND == mode_);
+  RTC_DCHECK(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());
     if (len_ + len < sizeof(buffer_) - 3) {
       len_ += len;
       ++header_;
     } else if (len_ == 0) {
       LOG(WARNING) << "discarding header that is too long: " << header_->first;
       ++header_;
     } else {
       // Not enough room for the next header, write to network first.
       return true;
     }
   }
   // End of headers
   len_ += strcpyn(buffer_ + len_, sizeof(buffer_) - len_, "\r\n");
   return false;
 }
 
 void
 HttpBase::do_complete(HttpError err) {
-  ASSERT(mode_ != HM_NONE);
+  RTC_DCHECK(mode_ != HM_NONE);
   HttpMode mode = mode_;
   mode_ = HM_NONE;
   if (data_ && data_->document) {
     data_->document->SignalEvent.disconnect(this);
   }
   data_ = NULL;
   if ((HM_RECV == mode) && doc_stream_) {
-    ASSERT(HE_NONE != err);  // We should have Disconnected doc_stream_ already.
+    RTC_DCHECK(HE_NONE !=
+               err);  // We should have Disconnected doc_stream_ already.
     DocumentStream* ds = doc_stream_;
     ds->Disconnect(err);
     ds->SignalEvent(ds, SE_CLOSE, err);
   }
   if (notify_) {
     notify_->onHttpComplete(mode, err);
   }
 }
 
 //
 // Stream Signals
 //
 
 void
 HttpBase::OnHttpStreamEvent(StreamInterface* stream, int events, int error) {
-  ASSERT(stream == http_stream_);
+  RTC_DCHECK(stream == http_stream_);
   if ((events & SE_OPEN) && (mode_ == HM_CONNECT)) {
     do_complete();
     return;
   }
 
   if ((events & SE_WRITE) && (mode_ == HM_SEND)) {
     flush_data();
     return;
   }
 
@@ skipping 14 matching lines @@
     complete(http_error);
   } else if (mode_ != HM_NONE) {
     do_complete(http_error);
   } else if (notify_) {
     notify_->onHttpClosed(http_error);
   }
 }
 
 void
 HttpBase::OnDocumentEvent(StreamInterface* stream, int events, int error) {
-  ASSERT(stream == data_->document.get());
+  RTC_DCHECK(stream == data_->document.get());
   if ((events & SE_WRITE) && (mode_ == HM_RECV)) {
     read_and_process_data();
     return;
   }
 
   if ((events & SE_READ) && (mode_ == HM_SEND)) {
     flush_data();
     return;
   }
 
@@ skipping 22 matching lines @@
   return PR_CONTINUE;
 }
 
 HttpParser::ProcessResult
 HttpBase::ProcessHeaderComplete(bool chunked, size_t& data_size,
                                 HttpError* error) {
   StreamInterface* old_docstream = doc_stream_;
   if (notify_) {
     *error = notify_->onHttpHeaderComplete(chunked, data_size);
     // The request must not be aborted as a result of this callback.
-    ASSERT(NULL != data_);
+    RTC_DCHECK(NULL != data_);
   }
   if ((HE_NONE == *error) && data_->document) {
     data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
   }
   if (HE_NONE != *error) {
     return PR_COMPLETE;
   }
   if (old_docstream != doc_stream_) {
     // Break out of Process loop, since our I/O model just changed.
     return PR_BLOCK;
@@ skipping 26 matching lines @@
   }
 }
 
 void
 HttpBase::OnComplete(HttpError err) {
   LOG_F(LS_VERBOSE);
   do_complete(err);
 }
 
 } // namespace rtc