Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/httpcommon.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 <time.h>
 
 #if defined(WEBRTC_WIN)
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #define SECURITY_WIN32
 #include <security.h>
 #endif
 
 #include <algorithm>
 
 #include "webrtc/base/arraysize.h"
 #include "webrtc/base/base64.h"
+#include "webrtc/base/checks.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/cryptstring.h"
 #include "webrtc/base/httpcommon-inl.h"
 #include "webrtc/base/httpcommon.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/socketaddress.h"
 #include "webrtc/base/stringencode.h"
 #include "webrtc/base/stringutils.h"
 
 namespace rtc {
@@ skipping 298 matching lines @@
     "UT", "GMT", "EST", "EDT", "CST", "CDT", "MST", "MDT", "PST", "PDT",
     "A", "B", "C", "D", "E", "F", "G", "H", "I", "K", "L", "M",
     "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y"
   };
   const int kTimeZoneOffsets[] = {
      0,  0, -5, -4, -6, -5, -7, -6, -8, -7,
     -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12,
      1,  2,  3,  4,  5,  6,  7,  8,  9,  10,  11,  12
   };
 
-  ASSERT(NULL != seconds);
+  RTC_DCHECK(NULL != seconds);
   struct tm tval;
   memset(&tval, 0, sizeof(tval));
   char month[4], zone[6];
   memset(month, 0, sizeof(month));
   memset(zone, 0, sizeof(zone));
 
   if (7 != sscanf(date.c_str(), "%*3s, %d %3s %d %d:%d:%d %5c",
                   &tval.tm_mday, month, &tval.tm_year,
                   &tval.tm_hour, &tval.tm_min, &tval.tm_sec, zone)) {
     return false;
@@ skipping 119 matching lines @@
 }
 
 void HttpData::setContent(const std::string& content_type,
                           StreamInterface* document) {
   setHeader(HH_CONTENT_TYPE, content_type);
   setDocumentAndLength(document);
 }
 
 void HttpData::setDocumentAndLength(StreamInterface* document) {
   // TODO: Consider calling Rewind() here?
-  ASSERT(!hasHeader(HH_CONTENT_LENGTH, NULL));
-  ASSERT(!hasHeader(HH_TRANSFER_ENCODING, NULL));
-  ASSERT(document != NULL);
+  RTC_DCHECK(!hasHeader(HH_CONTENT_LENGTH, NULL));
+  RTC_DCHECK(!hasHeader(HH_TRANSFER_ENCODING, NULL));
+  RTC_DCHECK(document != NULL);
   this->document.reset(document);
   size_t content_length = 0;
   if (this->document->GetAvailable(&content_length)) {
     char buffer[32];
     sprintfn(buffer, sizeof(buffer), "%d", content_length);
     setHeader(HH_CONTENT_LENGTH, buffer);
   } else {
     setHeader(HH_TRANSFER_ENCODING, "chunked");
   }
 }
@@ skipping 11 matching lines @@
 
 void
 HttpRequestData::copy(const HttpRequestData& src) {
   verb = src.verb;
   path = src.path;
   HttpData::copy(src);
 }
 
 size_t
 HttpRequestData::formatLeader(char* buffer, size_t size) const {
-  ASSERT(path.find(' ') == std::string::npos);
+  RTC_DCHECK(path.find(' ') == std::string::npos);
   return sprintfn(buffer, size, "%s %.*s HTTP/%s", ToString(verb), path.size(),
                   path.data(), ToString(version));
 }
 
 HttpError
 HttpRequestData::parseLeader(const char* line, size_t len) {
   unsigned int vmajor, vminor;
   int vend, dstart, dend;
   // sscanf isn't safe with strings that aren't null-terminated, and there is
   // no guarantee that |line| is. Create a local copy that is null-terminated.
@@ skipping 302 matching lines @@
     } else {
       middle = nonce;
     }
     std::string HA1 = MD5(sensitive);
     memset(sensitive, 0, len);
     delete [] sensitive;
     std::string HA2 = MD5(A2);
     std::string dig_response = MD5(HA1 + ":" + middle + ":" + HA2);
 
 #if TEST_DIGEST
-    ASSERT(strcmp(dig_response.c_str(), DIGEST_RESPONSE) == 0);
+    RTC_DCHECK(strcmp(dig_response.c_str(), DIGEST_RESPONSE) == 0);
 #endif
 
     std::stringstream ss;
     ss << auth_method;
     ss << " username=" << quote(username);
     ss << ", realm=" << quote(realm);
     ss << ", nonce=" << quote(nonce);
     ss << ", uri=" << quote(uri);
     if (has_qop) {
       ss << ", qop=" << qop;
@@ skipping 161 matching lines @@
       CtxtHandle ctx;
       ret = InitializeSecurityContextA(&cred, 0, spn, flags, 0, SECURITY_NATIVE_DREP, 0, 0, &ctx, &out_buf_desc, &ret_flags, &lifetime);
       //LOG(INFO) << "$$$ InitializeSecurityContext @ " << TimeSince(now);
       if (FAILED(ret)) {
         LOG(LS_ERROR) << "InitializeSecurityContext returned: "
                     << ErrorName(ret, SECURITY_ERRORS);
         FreeCredentialsHandle(&cred);
         return HAR_IGNORE;
       }
 
-      ASSERT(!context);
+      RTC_DCHECK(!context);
       context = neg = new NegotiateAuthContext(auth_method, cred, ctx);
       neg->specified_credentials = specify_credentials;
       neg->steps = steps;
     }
 
     if ((ret == SEC_I_COMPLETE_NEEDED) || (ret == SEC_I_COMPLETE_AND_CONTINUE)) {
       ret = CompleteAuthToken(&neg->ctx, &out_buf_desc);
       //LOG(INFO) << "$$$ CompleteAuthToken @ " << TimeSince(now);
       LOG(LS_VERBOSE) << "CompleteAuthToken returned: "
                       << ErrorName(ret, SECURITY_ERRORS);
@@ skipping 12 matching lines @@
   }
 #endif
 #endif // WEBRTC_WIN
 
   return HAR_IGNORE;
 }
 
 //////////////////////////////////////////////////////////////////////
 
 } // namespace rtc