Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/win32socketserver.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 233 matching lines @@
     UpdateLastError();
     return false;
   }
   if ((SOCK_DGRAM == type) && !SetAsync(FD_READ | FD_WRITE)) {
     return false;
   }
   return true;
 }
 
 int Win32Socket::Attach(SOCKET s) {
-  ASSERT(socket_ == INVALID_SOCKET);
+  RTC_DCHECK(socket_ == INVALID_SOCKET);
   if (socket_ != INVALID_SOCKET)
     return SOCKET_ERROR;
 
-  ASSERT(s != INVALID_SOCKET);
+  RTC_DCHECK(s != INVALID_SOCKET);
   if (s == INVALID_SOCKET)
     return SOCKET_ERROR;
 
   socket_ = s;
   state_ = CS_CONNECTED;
 
   if (!SetAsync(FD_READ | FD_WRITE | FD_CLOSE))
     return SOCKET_ERROR;
 
   return 0;
@@ skipping 28 matching lines @@
   if (result >= 0) {
     SocketAddressFromSockAddrStorage(addr, &address);
   } else {
     LOG(LS_WARNING) << "GetRemoteAddress: unable to get remote addr, socket="
                     << socket_;
   }
   return address;
 }
 
 int Win32Socket::Bind(const SocketAddress& addr) {
-  ASSERT(socket_ != INVALID_SOCKET);
+  RTC_DCHECK(socket_ != INVALID_SOCKET);
   if (socket_ == INVALID_SOCKET)
     return SOCKET_ERROR;
 
   sockaddr_storage saddr;
   size_t len = addr.ToSockAddrStorage(&saddr);
   int err = ::bind(socket_,
                    reinterpret_cast<sockaddr*>(&saddr),
                    static_cast<int>(len));
   UpdateLastError();
   return err;
@@ skipping 228 matching lines @@
       *mtu = PACKET_MAXIMUMS[level];
       return 0;
     }
   }
 
   RTC_NOTREACHED();
   return 0;
 }
 
 void Win32Socket::CreateSink() {
-  ASSERT(NULL == sink_);
+  RTC_DCHECK(NULL == sink_);
 
   // Create window
   sink_ = new EventSink(this);
   sink_->Create(NULL, L"EventSink", 0, 0, 0, 0, 10, 10);
 }
 
 bool Win32Socket::SetAsync(int events) {
   if (NULL == sink_) {
     CreateSink();
-    ASSERT(NULL != sink_);
+    RTC_DCHECK(NULL != sink_);
   }
 
   // start the async select
   if (WSAAsyncSelect(socket_, sink_->handle(), WM_SOCKETNOTIFY, events)
       == SOCKET_ERROR) {
     UpdateLastError();
     Close();
     return false;
   }
 
@@ skipping 209 matching lines @@
       } else if(b) {
         if (!hdlg_ || !IsDialogMessage(hdlg_, &msg)) {
           TranslateMessage(&msg);
           DispatchMessage(&msg);
         }
       }
       KillTimer(wnd_.handle(), 0);
     } while (b && TimeSince(start) < cms);
   } else if (cms != 0) {
     // Sit and wait forever for a WakeUp. This is the Thread::Send case.
-    ASSERT(cms == -1);
+    RTC_DCHECK(cms == -1);
     MSG msg;
     b = GetMessage(&msg, NULL, s_wm_wakeup_id, s_wm_wakeup_id);
     {
       CritScope scope(&cs_);
       posted_ = false;
     }
   } else {
     // No-op (cms == 0 && !process_io). This is the Pump case.
     b = TRUE;
   }
@@ skipping 47 matching lines @@
   bool handled = false;
   if (wm == s_wm_wakeup_id || (wm == WM_TIMER && wp == 1)) {
     ss_->Pump();
     lr = 0;
     handled = true;
   }
   return handled;
 }
 
 }  // namespace rtc