Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/examples/peerconnection/client/peer_connection_client.cc

 /*
  *  Copyright 2012 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/examples/peerconnection/client/peer_connection_client.h"
 
 #include "webrtc/examples/peerconnection/client/defaults.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/nethelpers.h"
 #include "webrtc/base/stringutils.h"
 
 #ifdef WIN32
 #include "webrtc/base/win32socketserver.h"
 #endif
 
 using rtc::sprintfn;
 
 namespace {
 
 // This is our magical hangup signal.
 const char kByeMessage[] = "BYE";
 // Delay between server connection retries, in milliseconds
 const int kReconnectDelay = 2000;
 
 rtc::AsyncSocket* CreateClientSocket(int family) {
 #ifdef WIN32
   rtc::Win32Socket* sock = new rtc::Win32Socket();
   sock->CreateT(family, SOCK_STREAM);
   return sock;
 #elif defined(WEBRTC_POSIX)
   rtc::Thread* thread = rtc::Thread::Current();
-  ASSERT(thread != NULL);
+  RTC_DCHECK(thread != NULL);
   return thread->socketserver()->CreateAsyncSocket(family, SOCK_STREAM);
 #else
 #error Platform not supported.
 #endif
 }
 
 }  // namespace
 
 PeerConnectionClient::PeerConnectionClient()
   : callback_(NULL),
     resolver_(NULL),
     state_(NOT_CONNECTED),
     my_id_(-1) {
 }
 
 PeerConnectionClient::~PeerConnectionClient() {
 }
 
 void PeerConnectionClient::InitSocketSignals() {
-  ASSERT(control_socket_.get() != NULL);
-  ASSERT(hanging_get_.get() != NULL);
+  RTC_DCHECK(control_socket_.get() != NULL);
+  RTC_DCHECK(hanging_get_.get() != NULL);
   control_socket_->SignalCloseEvent.connect(this,
       &PeerConnectionClient::OnClose);
   hanging_get_->SignalCloseEvent.connect(this,
       &PeerConnectionClient::OnClose);
   control_socket_->SignalConnectEvent.connect(this,
       &PeerConnectionClient::OnConnect);
   hanging_get_->SignalConnectEvent.connect(this,
       &PeerConnectionClient::OnHangingGetConnect);
   control_socket_->SignalReadEvent.connect(this,
       &PeerConnectionClient::OnRead);
   hanging_get_->SignalReadEvent.connect(this,
       &PeerConnectionClient::OnHangingGetRead);
 }
 
 int PeerConnectionClient::id() const {
   return my_id_;
 }
 
 bool PeerConnectionClient::is_connected() const {
   return my_id_ != -1;
 }
 
 const Peers& PeerConnectionClient::peers() const {
   return peers_;
 }
 
 void PeerConnectionClient::RegisterObserver(
     PeerConnectionClientObserver* callback) {
-  ASSERT(!callback_);
+  RTC_DCHECK(!callback_);
   callback_ = callback;
 }
 
 void PeerConnectionClient::Connect(const std::string& server, int port,
                                    const std::string& client_name) {
-  ASSERT(!server.empty());
-  ASSERT(!client_name.empty());
+  RTC_DCHECK(!server.empty());
+  RTC_DCHECK(!client_name.empty());
 
   if (state_ != NOT_CONNECTED) {
     LOG(WARNING)
         << "The client must not be connected before you can call Connect()";
     callback_->OnServerConnectionFailure();
     return;
   }
 
   if (server.empty() || client_name.empty()) {
     callback_->OnServerConnectionFailure();
@@ skipping 44 matching lines @@
     state_ = SIGNING_IN;
   if (!ret) {
     callback_->OnServerConnectionFailure();
   }
 }
 
 bool PeerConnectionClient::SendToPeer(int peer_id, const std::string& message) {
   if (state_ != CONNECTED)
     return false;
 
-  ASSERT(is_connected());
-  ASSERT(control_socket_->GetState() == rtc::Socket::CS_CLOSED);
+  RTC_DCHECK(is_connected());
+  RTC_DCHECK(control_socket_->GetState() == rtc::Socket::CS_CLOSED);
   if (!is_connected() || peer_id == -1)
     return false;
 
   char headers[1024];
   sprintfn(headers, sizeof(headers),
       "POST /message?peer_id=%i&to=%i HTTP/1.0\r\n"
       "Content-Length: %i\r\n"
       "Content-Type: text/plain\r\n"
       "\r\n",
       my_id_, peer_id, message.length());
@@ skipping 45 matching lines @@
   peers_.clear();
   if (resolver_ != NULL) {
     resolver_->Destroy(false);
     resolver_ = NULL;
   }
   my_id_ = -1;
   state_ = NOT_CONNECTED;
 }
 
 bool PeerConnectionClient::ConnectControlSocket() {
-  ASSERT(control_socket_->GetState() == rtc::Socket::CS_CLOSED);
+  RTC_DCHECK(control_socket_->GetState() == rtc::Socket::CS_CLOSED);
   int err = control_socket_->Connect(server_address_);
   if (err == SOCKET_ERROR) {
     Close();
     return false;
   }
   return true;
 }
 
 void PeerConnectionClient::OnConnect(rtc::AsyncSocket* socket) {
-  ASSERT(!onconnect_data_.empty());
+  RTC_DCHECK(!onconnect_data_.empty());
   size_t sent = socket->Send(onconnect_data_.c_str(), onconnect_data_.length());
-  ASSERT(sent == onconnect_data_.length());
+  RTC_DCHECK(sent == onconnect_data_.length());
   RTC_UNUSED(sent);
   onconnect_data_.clear();
 }
 
 void PeerConnectionClient::OnHangingGetConnect(rtc::AsyncSocket* socket) {
   char buffer[1024];
   sprintfn(buffer, sizeof(buffer),
            "GET /wait?peer_id=%i HTTP/1.0\r\n\r\n", my_id_);
   int len = static_cast<int>(strlen(buffer));
   int sent = socket->Send(buffer, len);
-  ASSERT(sent == len);
+  RTC_DCHECK(sent == len);
   RTC_UNUSED2(sent, len);
 }
 
 void PeerConnectionClient::OnMessageFromPeer(int peer_id,
                                              const std::string& message) {
   if (message.length() == (sizeof(kByeMessage) - 1) &&
       message.compare(kByeMessage) == 0) {
     callback_->OnPeerDisconnected(peer_id);
   } else {
     callback_->OnMessageFromPeer(peer_id, message);
   }
 }
 
 bool PeerConnectionClient::GetHeaderValue(const std::string& data,
                                           size_t eoh,
                                           const char* header_pattern,
                                           size_t* value) {
-  ASSERT(value != NULL);
+  RTC_DCHECK(value != NULL);
   size_t found = data.find(header_pattern);
   if (found != std::string::npos && found < eoh) {
     *value = atoi(&data[found + strlen(header_pattern)]);
     return true;
   }
   return false;
 }
 
 bool PeerConnectionClient::GetHeaderValue(const std::string& data, size_t eoh,
                                           const char* header_pattern,
                                           std::string* value) {
-  ASSERT(value != NULL);
+  RTC_DCHECK(value != NULL);
   size_t found = data.find(header_pattern);
   if (found != std::string::npos && found < eoh) {
     size_t begin = found + strlen(header_pattern);
     size_t end = data.find("\r\n", begin);
     if (end == std::string::npos)
       end = eoh;
     value->assign(data.substr(begin, end - begin));
     return true;
   }
   return false;
@@ skipping 39 matching lines @@
 
 void PeerConnectionClient::OnRead(rtc::AsyncSocket* socket) {
   size_t content_length = 0;
   if (ReadIntoBuffer(socket, &control_data_, &content_length)) {
     size_t peer_id = 0, eoh = 0;
     bool ok = ParseServerResponse(control_data_, content_length, &peer_id,
                                   &eoh);
     if (ok) {
       if (my_id_ == -1) {
         // First response.  Let's store our server assigned ID.
-        ASSERT(state_ == SIGNING_IN);
+        RTC_DCHECK(state_ == SIGNING_IN);
         my_id_ = static_cast<int>(peer_id);
-        ASSERT(my_id_ != -1);
+        RTC_DCHECK(my_id_ != -1);
 
         // The body of the response will be a list of already connected peers.
         if (content_length) {
           size_t pos = eoh + 4;
           while (pos < control_data_.size()) {
             size_t eol = control_data_.find('\n', pos);
             if (eol == std::string::npos)
               break;
             int id = 0;
             std::string name;
             bool connected;
             if (ParseEntry(control_data_.substr(pos, eol - pos), &name, &id,
                            &connected) && id != my_id_) {
               peers_[id] = name;
               callback_->OnPeerConnected(id, name);
             }
             pos = eol + 1;
           }
         }
-        ASSERT(is_connected());
+        RTC_DCHECK(is_connected());
         callback_->OnSignedIn();
       } else if (state_ == SIGNING_OUT) {
         Close();
         callback_->OnDisconnected();
       } else if (state_ == SIGNING_OUT_WAITING) {
         SignOut();
       }
     }
 
     control_data_.clear();
 
     if (state_ == SIGNING_IN) {
-      ASSERT(hanging_get_->GetState() == rtc::Socket::CS_CLOSED);
+      RTC_DCHECK(hanging_get_->GetState() == rtc::Socket::CS_CLOSED);
       state_ = CONNECTED;
       hanging_get_->Connect(server_address_);
     }
   }
 }
 
 void PeerConnectionClient::OnHangingGetRead(rtc::AsyncSocket* socket) {
   LOG(INFO) << __FUNCTION__;
   size_t content_length = 0;
   if (ReadIntoBuffer(socket, &notification_data_, &content_length)) {
@@ skipping 33 matching lines @@
   if (hanging_get_->GetState() == rtc::Socket::CS_CLOSED &&
       state_ == CONNECTED) {
     hanging_get_->Connect(server_address_);
   }
 }
 
 bool PeerConnectionClient::ParseEntry(const std::string& entry,
                                       std::string* name,
                                       int* id,
                                       bool* connected) {
-  ASSERT(name != NULL);
-  ASSERT(id != NULL);
-  ASSERT(connected != NULL);
-  ASSERT(!entry.empty());
+  RTC_DCHECK(name != NULL);
+  RTC_DCHECK(id != NULL);
+  RTC_DCHECK(connected != NULL);
+  RTC_DCHECK(!entry.empty());
 
   *connected = false;
   size_t separator = entry.find(',');
   if (separator != std::string::npos) {
     *id = atoi(&entry[separator + 1]);
     name->assign(entry.substr(0, separator));
     separator = entry.find(',', separator + 1);
     if (separator != std::string::npos) {
       *connected = atoi(&entry[separator + 1]) ? true : false;
     }
@@ skipping 15 matching lines @@
                                                size_t* eoh) {
   int status = GetResponseStatus(response.c_str());
   if (status != 200) {
     LOG(LS_ERROR) << "Received error from server";
     Close();
     callback_->OnDisconnected();
     return false;
   }
 
   *eoh = response.find("\r\n\r\n");
-  ASSERT(*eoh != std::string::npos);
+  RTC_DCHECK(*eoh != std::string::npos);
   if (*eoh == std::string::npos)
     return false;
 
   *peer_id = -1;
 
   // See comment in peer_channel.cc for why we use the Pragma header and
   // not e.g. "X-Peer-Id".
   GetHeaderValue(response, *eoh, "\r\nPragma: ", peer_id);
 
   return true;
@@ skipping 26 matching lines @@
       Close();
       callback_->OnDisconnected();
     }
   }
 }
 
 void PeerConnectionClient::OnMessage(rtc::Message* msg) {
   // ignore msg; there is currently only one supported message ("retry")
   DoConnect();
 }