Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/stream.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 416 matching lines @@
   }
 }
 
 bool FileStream::SetPosition(size_t position) {
   if (!file_)
     return false;
   return (fseek(file_, static_cast<int>(position), SEEK_SET) == 0);
 }
 
 bool FileStream::GetPosition(size_t* position) const {
-  ASSERT(NULL != position);
+  RTC_DCHECK(NULL != position);
   if (!file_)
     return false;
   long result = ftell(file_);
   if (result < 0)
     return false;
   if (position)
     *position = result;
   return true;
 }
 
 bool FileStream::GetSize(size_t* size) const {
-  ASSERT(NULL != size);
+  RTC_DCHECK(NULL != size);
   if (!file_)
     return false;
   struct stat file_stats;
   if (fstat(fileno(file_), &file_stats) != 0)
     return false;
   if (size)
     *size = file_stats.st_size;
   return true;
 }
 
 bool FileStream::GetAvailable(size_t* size) const {
-  ASSERT(NULL != size);
+  RTC_DCHECK(NULL != size);
   if (!GetSize(size))
     return false;
   long result = ftell(file_);
   if (result < 0)
     return false;
   if (size)
     *size -= result;
   return true;
 }
 
@@ skipping 84 matching lines @@
   if (0 == available) {
     // Increase buffer size to the larger of:
     // a) new position rounded up to next 256 bytes
     // b) double the previous length
     size_t new_buffer_length =
         std::max(((seek_position_ + bytes) | 0xFF) + 1, buffer_length_ * 2);
     StreamResult result = DoReserve(new_buffer_length, error);
     if (SR_SUCCESS != result) {
       return result;
     }
-    ASSERT(buffer_length_ >= new_buffer_length);
+    RTC_DCHECK(buffer_length_ >= new_buffer_length);
     available = buffer_length_ - seek_position_;
   }
 
   if (bytes > available) {
     bytes = available;
   }
   memcpy(&buffer_[seek_position_], buffer, bytes);
   seek_position_ += bytes;
   if (data_length_ < seek_position_) {
     data_length_ = seek_position_;
@@ skipping 224 matching lines @@
 
 const void* FifoBuffer::GetReadData(size_t* size) {
   CritScope cs(&crit_);
   *size = (read_position_ + data_length_ <= buffer_length_) ?
       data_length_ : buffer_length_ - read_position_;
   return &buffer_[read_position_];
 }
 
 void FifoBuffer::ConsumeReadData(size_t size) {
   CritScope cs(&crit_);
-  ASSERT(size <= data_length_);
+  RTC_DCHECK(size <= data_length_);
   const bool was_writable = data_length_ < buffer_length_;
   read_position_ = (read_position_ + size) % buffer_length_;
   data_length_ -= size;
   if (!was_writable && size > 0) {
     PostEvent(owner_, SE_WRITE, 0);
   }
 }
 
 void* FifoBuffer::GetWriteBuffer(size_t* size) {
   CritScope cs(&crit_);
   if (state_ == SS_CLOSED) {
     return NULL;
   }
 
   // if empty, reset the write position to the beginning, so we can get
   // the biggest possible block
   if (data_length_ == 0) {
     read_position_ = 0;
   }
 
   const size_t write_position = (read_position_ + data_length_)
       % buffer_length_;
   *size = (write_position > read_position_ || data_length_ == 0) ?
       buffer_length_ - write_position : read_position_ - write_position;
   return &buffer_[write_position];
 }
 
 void FifoBuffer::ConsumeWriteBuffer(size_t size) {
   CritScope cs(&crit_);
-  ASSERT(size <= buffer_length_ - data_length_);
+  RTC_DCHECK(size <= buffer_length_ - data_length_);
   const bool was_readable = (data_length_ > 0);
   data_length_ += size;
   if (!was_readable && size > 0) {
     PostEvent(owner_, SE_READ, 0);
   }
 }
 
 bool FifoBuffer::GetWriteRemaining(size_t* size) const {
   CritScope cs(&crit_);
   *size = buffer_length_ - data_length_;
@@ skipping 211 matching lines @@
     : StreamAdapterInterface(stream, false),
       stream_ref_count_(stream_ref_count) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 StreamResult Flow(StreamInterface* source,
                   char* buffer, size_t buffer_len,
                   StreamInterface* sink,
                   size_t* data_len /* = NULL */) {
-  ASSERT(buffer_len > 0);
+  RTC_DCHECK(buffer_len > 0);
 
   StreamResult result;
   size_t count, read_pos, write_pos;
   if (data_len) {
     read_pos = *data_len;
   } else {
     read_pos = 0;
   }
 
   bool end_of_stream = false;
@@ skipping 36 matching lines @@
 
   if (data_len) {
     *data_len = 0;
   }
   return SR_SUCCESS;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc