Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/physicalsocketserver.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 "webrtc/base/physicalsocketserver.h"
@@ skipping 294 matching lines @@
       // don't want. By specifying this flag, we'll just get the error EPIPE
       // instead and can handle the error gracefully.
       MSG_NOSIGNAL
 #else
       0
 #endif
       );
   UpdateLastError();
   MaybeRemapSendError();
   // We have seen minidumps where this may be false.
-  ASSERT(sent <= static_cast<int>(cb));
+  RTC_DCHECK(sent <= static_cast<int>(cb));
   if ((sent > 0 && sent < static_cast<int>(cb)) ||
       (sent < 0 && IsBlockingError(GetError()))) {
     enabled_events_ |= DE_WRITE;
   }
   return sent;
 }
 
 int PhysicalSocket::SendTo(const void* buffer,
                            size_t length,
                            const SocketAddress& addr) {
   sockaddr_storage saddr;
   size_t len = addr.ToSockAddrStorage(&saddr);
   int sent = DoSendTo(
       s_, static_cast<const char *>(buffer), static_cast<int>(length),
 #if defined(WEBRTC_LINUX) && !defined(WEBRTC_ANDROID)
       // Suppress SIGPIPE. See above for explanation.
       MSG_NOSIGNAL,
 #else
       0,
 #endif
       reinterpret_cast<sockaddr*>(&saddr), static_cast<int>(len));
   UpdateLastError();
   MaybeRemapSendError();
   // We have seen minidumps where this may be false.
-  ASSERT(sent <= static_cast<int>(length));
+  RTC_DCHECK(sent <= static_cast<int>(length));
   if ((sent > 0 && sent < static_cast<int>(length)) ||
       (sent < 0 && IsBlockingError(GetError()))) {
     enabled_events_ |= DE_WRITE;
   }
   return sent;
 }
 
 int PhysicalSocket::Recv(void* buffer, size_t length, int64_t* timestamp) {
   int received = ::recv(s_, static_cast<char*>(buffer),
                         static_cast<int>(length), 0);
@@ skipping 141 matching lines @@
 #elif defined(WEBRTC_LINUX)
   // Gets the path MTU.
   int value;
   socklen_t vlen = sizeof(value);
   int err = getsockopt(s_, IPPROTO_IP, IP_MTU, &value, &vlen);
   if (err < 0) {
     UpdateLastError();
     return err;
   }
 
-  ASSERT((0 <= value) && (value <= 65536));
+  RTC_DCHECK((0 <= value) && (value <= 65536));
   *mtu = value;
   return 0;
 #elif defined(__native_client__)
   // Most socket operations, including this, will fail in NaCl's sandbox.
   error_ = EACCES;
   return -1;
 #endif
 }
 
 SOCKET PhysicalSocket::DoAccept(SOCKET socket,
@@ skipping 105 matching lines @@
   : PhysicalSocket(ss, s)
 #endif
 {
 }
 
 SocketDispatcher::~SocketDispatcher() {
   Close();
 }
 
 bool SocketDispatcher::Initialize() {
-  ASSERT(s_ != INVALID_SOCKET);
+  RTC_DCHECK(s_ != INVALID_SOCKET);
   // Must be a non-blocking
 #if defined(WEBRTC_WIN)
   u_long argp = 1;
   ioctlsocket(s_, FIONBIO, &argp);
 #elif defined(WEBRTC_POSIX)
   fcntl(s_, F_SETFL, fcntl(s_, F_GETFL, 0) | O_NONBLOCK);
 #endif
   ss_->Add(this);
   return true;
 }
@@ skipping 244 matching lines @@
   // There is just a single global instance. (Signal handlers do not get any
   // sort of user-defined void * parameter, so they can't access anything that
   // isn't global.)
   static PosixSignalHandler* Instance() {
     RTC_DEFINE_STATIC_LOCAL(PosixSignalHandler, instance, ());
     return &instance;
   }
 
   // Returns true if the given signal number is set.
   bool IsSignalSet(int signum) const {
-    ASSERT(signum < static_cast<int>(arraysize(received_signal_)));
+    RTC_DCHECK(signum < static_cast<int>(arraysize(received_signal_)));
     if (signum < static_cast<int>(arraysize(received_signal_))) {
       return received_signal_[signum];
     } else {
       return false;
     }
   }
 
   // Clears the given signal number.
   void ClearSignal(int signum) {
-    ASSERT(signum < static_cast<int>(arraysize(received_signal_)));
+    RTC_DCHECK(signum < static_cast<int>(arraysize(received_signal_)));
     if (signum < static_cast<int>(arraysize(received_signal_))) {
       received_signal_[signum] = false;
     }
   }
 
   // Returns the file descriptor to monitor for signal events.
   int GetDescriptor() const {
     return afd_[0];
   }
 
@@ skipping 224 matching lines @@
 }
 
 PhysicalSocketServer::~PhysicalSocketServer() {
 #if defined(WEBRTC_WIN)
   WSACloseEvent(socket_ev_);
 #endif
 #if defined(WEBRTC_POSIX)
   signal_dispatcher_.reset();
 #endif
   delete signal_wakeup_;
-  ASSERT(dispatchers_.empty());
+  RTC_DCHECK(dispatchers_.empty());
 }
 
 void PhysicalSocketServer::WakeUp() {
   signal_wakeup_->Signal();
 }
 
 Socket* PhysicalSocketServer::CreateSocket(int type) {
   return CreateSocket(AF_INET, type);
 }
 
@@ skipping 105 matching lines @@
 
   fWait_ = true;
 
   while (fWait_) {
     int fdmax = -1;
     {
       CritScope cr(&crit_);
       for (size_t i = 0; i < dispatchers_.size(); ++i) {
         // Query dispatchers for read and write wait state
         Dispatcher *pdispatcher = dispatchers_[i];
-        ASSERT(pdispatcher);
+        RTC_DCHECK(pdispatcher);
         if (!process_io && (pdispatcher != signal_wakeup_))
           continue;
         int fd = pdispatcher->GetDescriptor();
         if (fd > fdmax)
           fdmax = fd;
 
         uint32_t ff = pdispatcher->GetRequestedEvents();
         if (ff & (DE_READ | DE_ACCEPT))
           FD_SET(fd, &fdsRead);
         if (ff & (DE_WRITE | DE_CONNECT))
@@ skipping 80 matching lines @@
       ptvWait->tv_sec = 0;
       ptvWait->tv_usec = 0;
       struct timeval tvT;
       gettimeofday(&tvT, NULL);
       if ((tvStop.tv_sec > tvT.tv_sec)
           || ((tvStop.tv_sec == tvT.tv_sec)
               && (tvStop.tv_usec > tvT.tv_usec))) {
         ptvWait->tv_sec = tvStop.tv_sec - tvT.tv_sec;
         ptvWait->tv_usec = tvStop.tv_usec - tvT.tv_usec;
         if (ptvWait->tv_usec < 0) {
-          ASSERT(ptvWait->tv_sec > 0);
+          RTC_DCHECK(ptvWait->tv_sec > 0);
           ptvWait->tv_usec += 1000000;
           ptvWait->tv_sec -= 1;
         }
       }
     }
   }
 
   return true;
 }
 
@@ skipping 83 matching lines @@
           // We just signalled close, don't poll this socket
         } else if (s != INVALID_SOCKET) {
           WSAEventSelect(s,
                          events[0],
                          FlagsToEvents(disp->GetRequestedEvents()));
         } else {
           events.push_back(disp->GetWSAEvent());
           event_owners.push_back(disp);
         }
       }
-      ASSERT(iterators_.back() == &i);
+      RTC_DCHECK(iterators_.back() == &i);
       iterators_.pop_back();
     }
 
     // Which is shorter, the delay wait or the asked wait?
 
     int64_t cmsNext;
     if (cmsWait == kForever) {
       cmsNext = cmsWait;
     } else {
       cmsNext = std::max<int64_t>(0, cmsTotal - cmsElapsed);
@@ skipping 82 matching lines @@
             if (wsaEvents.lNetworkEvents & FD_CLOSE) {
               ff |= DE_CLOSE;
               errcode = wsaEvents.iErrorCode[FD_CLOSE_BIT];
             }
             if (ff != 0) {
               disp->OnPreEvent(ff);
               disp->OnEvent(ff, errcode);
             }
           }
         }
-        ASSERT(iterators_.back() == &end);
+        RTC_DCHECK(iterators_.back() == &end);
         iterators_.pop_back();
-        ASSERT(iterators_.back() == &i);
+        RTC_DCHECK(iterators_.back() == &i);
         iterators_.pop_back();
       }
 
       // Reset the network event until new activity occurs
       WSAResetEvent(socket_ev_);
     }
 
     // Break?
     if (!fWait_)
       break;
     cmsElapsed = TimeSince(msStart);
     if ((cmsWait != kForever) && (cmsElapsed >= cmsWait)) {
        break;
     }
   }
 
   // Done
   return true;
 }
 #endif  // WEBRTC_WIN
 
 }  // namespace rtc