Replace ASSERT by RTC_DCHECK in all non-test code.

webrtc/base/httpclient.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 19 matching lines @@
 // Helpers
 //////////////////////////////////////////////////////////////////////
 
 namespace {
 
 const size_t kCacheHeader = 0;
 const size_t kCacheBody = 1;
 
 // Convert decimal string to integer
 bool HttpStringToUInt(const std::string& str, size_t* val) {
-  ASSERT(NULL != val);
+  RTC_DCHECK(NULL != val);
   char* eos = NULL;
   *val = strtoul(str.c_str(), &eos, 10);
   return (*eos == '\0');
 }
 
 bool HttpShouldCache(const HttpTransaction& t) {
   bool verb_allows_cache = (t.request.verb == HV_GET)
                            || (t.request.verb == HV_HEAD);
   bool is_range_response = t.response.hasHeader(HH_CONTENT_RANGE, NULL);
   bool has_expires = t.response.hasHeader(HH_EXPIRES, NULL);
@@ skipping 283 matching lines @@
   return base_.GetDocumentStream();
 }
 
 void HttpClient::start() {
   if (base_.mode() != HM_NONE) {
     // call reset() to abort an in-progress request
     RTC_NOTREACHED();
     return;
   }
 
-  ASSERT(!IsCacheActive());
+  RTC_DCHECK(!IsCacheActive());
 
   if (request().hasHeader(HH_TRANSFER_ENCODING, NULL)) {
     // Exact size must be known on the client.  Instead of using chunked
     // encoding, wrap data with auto-caching file or memory stream.
     RTC_NOTREACHED();
     return;
   }
 
   attempt_ = 0;
 
@@ skipping 41 matching lines @@
 }
 
 void HttpClient::connect() {
   int stream_err;
   if (server_.IsUnresolvedIP()) {
     StartDNSLookup();
     return;
   }
   StreamInterface* stream = pool_->RequestConnectedStream(server_, &stream_err);
   if (stream == NULL) {
-    ASSERT(0 != stream_err);
+    RTC_DCHECK(0 != stream_err);
     LOG(LS_ERROR) << "RequestConnectedStream error: " << stream_err;
     onHttpComplete(HM_CONNECT, HE_CONNECT_FAILED);
   } else {
     base_.attach(stream);
     if (stream->GetState() == SS_OPEN) {
       base_.send(&transaction_->request);
     }
   }
 }
 
@@ skipping 29 matching lines @@
       || !response().hasHeader(HH_LOCATION, location)
       || (redirects_ >= kMaxRedirects))
     return false;
   return (REDIRECT_ALWAYS == redirect_action_)
          || (HC_SEE_OTHER == response().scode)
          || (HV_HEAD == request().verb)
          || (HV_GET == request().verb);
 }
 
 bool HttpClient::BeginCacheFile() {
-  ASSERT(NULL != cache_);
-  ASSERT(CS_READY == cache_state_);
+  RTC_DCHECK(NULL != cache_);
+  RTC_DCHECK(CS_READY == cache_state_);
 
   std::string id = GetCacheID(request());
   CacheLock lock(cache_, id, true);
   if (!lock.IsLocked()) {
     LOG_F(LS_WARNING) << "Couldn't lock cache";
     return false;
   }
 
   if (HE_NONE != WriteCacheHeaders(id)) {
     return false;
@@ skipping 45 matching lines @@
   // Delete the tap and cache stream (which completes cache unlock)
   delete tap;
 
   if (SR_SUCCESS != result) {
     LOG(LS_ERROR) << "Cache file error: " << error;
     cache_->DeleteResource(GetCacheID(request()));
   }
 }
 
 bool HttpClient::CheckCache() {
-  ASSERT(NULL != cache_);
-  ASSERT(CS_READY == cache_state_);
+  RTC_DCHECK(NULL != cache_);
+  RTC_DCHECK(CS_READY == cache_state_);
 
   std::string id = GetCacheID(request());
   if (!cache_->HasResource(id)) {
     // No cache file available
     return false;
   }
 
   HttpError error = ReadCacheHeaders(id, true);
 
   if (HE_NONE == error) {
@@ skipping 73 matching lines @@
                                response().document.get());
     if (SR_SUCCESS != result) {
       error = HE_STREAM;
     }
   }
 
   return error;
 }
 
 bool HttpClient::PrepareValidate() {
-  ASSERT(CS_READY == cache_state_);
+  RTC_DCHECK(CS_READY == cache_state_);
   // At this point, request() contains the pending request, and response()
   // contains the cached response headers.  Reformat the request to validate
   // the cached content.
   HttpValidatorStrength vs_required = HttpRequestValidatorLevel(request());
   HttpValidatorStrength vs_available = HttpResponseValidatorLevel(response());
   if (vs_available < vs_required) {
     return false;
   }
   std::string value;
   if (response().hasHeader(HH_ETAG, &value)) {
     request().addHeader(HH_IF_NONE_MATCH, value);
   }
   if (response().hasHeader(HH_LAST_MODIFIED, &value)) {
     request().addHeader(HH_IF_MODIFIED_SINCE, value);
   }
   response().clear(false);
   cache_state_ = CS_VALIDATING;
   return true;
 }
 
 HttpError HttpClient::CompleteValidate() {
-  ASSERT(CS_VALIDATING == cache_state_);
+  RTC_DCHECK(CS_VALIDATING == cache_state_);
 
   std::string id = GetCacheID(request());
 
   // Merge cached headers with new headers
   HttpError error = ReadCacheHeaders(id, false);
   if (HE_NONE != error) {
     // Rewrite merged headers to cache
     CacheLock lock(cache_, id);
     error = WriteCacheHeaders(id);
   }
@@ skipping 28 matching lines @@
   if (CS_VALIDATING == cache_state_) {
     if (HC_NOT_MODIFIED == response().scode) {
       return CompleteValidate();
     }
     // Should we remove conditional headers from request?
     cache_state_ = CS_READY;
     cache_->DeleteResource(GetCacheID(request()));
     // Continue processing response as normal
   }
 
-  ASSERT(!IsCacheActive());
+  RTC_DCHECK(!IsCacheActive());
   if ((request().verb == HV_HEAD) || !HttpCodeHasBody(response().scode)) {
     // HEAD requests and certain response codes contain no body
     data_size = 0;
   }
   if (ShouldRedirect(NULL)
       || ((HC_PROXY_AUTHENTICATION_REQUIRED == response().scode)
           && (PROXY_HTTPS == proxy_.type))) {
     // We're going to issue another request, so ignore the incoming data.
     base_.set_ignore_data(true);
   }
@@ skipping 50 matching lines @@
       Url<char> purl(location);
       set_server(SocketAddress(purl.host(), purl.port()));
       request().path = purl.full_path();
       if (response().scode == HC_SEE_OTHER) {
         request().verb = HV_GET;
         request().clearHeader(HH_CONTENT_TYPE);
         request().clearHeader(HH_CONTENT_LENGTH);
         request().document.reset();
       } else if (request().document && !request().document->Rewind()) {
         // Unable to replay the request document.
-        ASSERT(REDIRECT_ALWAYS == redirect_action_);
+        RTC_DCHECK(REDIRECT_ALWAYS == redirect_action_);
         err = HE_STREAM;
       }
       if (err == HE_NONE) {
         ++redirects_;
         context_.reset();
         response().clear(false);
         release();
         start();
         return;
       }
@@ skipping 56 matching lines @@
                                      const std::string& agent,
                                      HttpTransaction* transaction)
     : ReuseSocketPool(factory ? factory : Thread::Current()->socketserver()),
       HttpClient(agent, NULL, transaction) {
   set_pool(this);
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc