Replace NULL with nullptr in all C++ files.

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) {
-  RTC_DCHECK(NULL != val);
-  char* eos = NULL;
+  RTC_DCHECK(nullptr != val);
+  char* eos = nullptr;
   *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);
+  bool is_range_response = t.response.hasHeader(HH_CONTENT_RANGE, nullptr);
+  bool has_expires = t.response.hasHeader(HH_EXPIRES, nullptr);
   bool request_allows_cache =
     has_expires || (std::string::npos != t.request.path.find('?'));
   bool response_allows_cache =
     has_expires || HttpCodeIsCacheable(t.response.scode);
 
   bool may_cache = verb_allows_cache
                    && request_allows_cache
                    && response_allows_cache
                    && !is_range_response;
 
   std::string value;
   if (t.response.hasHeader(HH_CACHE_CONTROL, &value)) {
     HttpAttributeList directives;
     HttpParseAttributes(value.data(), value.size(), directives);
     // Response Directives Summary:
     // public - always cacheable
     // private - do not cache in a shared cache
     // no-cache - may cache, but must revalidate whether fresh or stale
     // no-store - sensitive information, do not cache or store in any way
     // max-age - supplants Expires for staleness
     // s-maxage - use as max-age for shared caches, ignore otherwise
     // must-revalidate - may cache, but must revalidate after stale
     // proxy-revalidate - shared cache must revalidate
-    if (HttpHasAttribute(directives, "no-store", NULL)) {
+    if (HttpHasAttribute(directives, "no-store", nullptr)) {
       may_cache = false;
-    } else if (HttpHasAttribute(directives, "public", NULL)) {
+    } else if (HttpHasAttribute(directives, "public", nullptr)) {
       may_cache = true;
     }
   }
   return may_cache;
 }
 
 enum HttpCacheState {
   HCS_FRESH,  // In cache, may use
   HCS_STALE,  // In cache, must revalidate
   HCS_NONE    // Not in cache
@@ skipping 61 matching lines @@
 enum HttpValidatorStrength {
   HVS_NONE,
   HVS_WEAK,
   HVS_STRONG
 };
 
 HttpValidatorStrength
 HttpRequestValidatorLevel(const HttpRequestData& request) {
   if (HV_GET != request.verb)
     return HVS_STRONG;
-  return request.hasHeader(HH_RANGE, NULL) ? HVS_STRONG : HVS_WEAK;
+  return request.hasHeader(HH_RANGE, nullptr) ? HVS_STRONG : HVS_WEAK;
 }
 
 HttpValidatorStrength
 HttpResponseValidatorLevel(const HttpResponseData& response) {
   std::string value;
   if (response.hasHeader(HH_ETAG, &value)) {
     bool is_weak = (strnicmp(value.c_str(), "W/", 2) == 0);
     return is_weak ? HVS_WEAK : HVS_STRONG;
   }
   if (response.hasHeader(HH_LAST_MODIFIED, &value)) {
@@ skipping 33 matching lines @@
     HttpHeader header;
     if (FromString(header, it->first) && !HttpHeaderIsEndToEnd(header))
       continue;
     length += it->first.length() + 2 + it->second.length() + 2;
     if (!output)
       continue;
     std::string formatted_header(it->first);
     formatted_header.append(": ");
     formatted_header.append(it->second);
     formatted_header.append("\r\n");
-    StreamResult result = output->WriteAll(formatted_header.data(),
-                                           formatted_header.length(),
-                                           NULL, NULL);
+    StreamResult result = output->WriteAll(
+        formatted_header.data(), formatted_header.length(), nullptr, nullptr);
     if (SR_SUCCESS != result) {
       return false;
     }
   }
-  if (output && (SR_SUCCESS != output->WriteAll("\r\n", 2, NULL, NULL))) {
+  if (output && (SR_SUCCESS != output->WriteAll("\r\n", 2, nullptr, nullptr))) {
     return false;
   }
   length += 2;
   if (size)
     *size = length;
   return true;
 }
 
 bool HttpReadCacheHeaders(StreamInterface* input, HttpResponseData* response,
                           HttpData::HeaderCombine combine) {
@@ skipping 28 matching lines @@
   return true;
 }
 
 //////////////////////////////////////////////////////////////////////
 // HttpClient
 //////////////////////////////////////////////////////////////////////
 
 const size_t kDefaultRetries = 1;
 const size_t kMaxRedirects = 5;
 
-HttpClient::HttpClient(const std::string& agent, StreamPool* pool,
+HttpClient::HttpClient(const std::string& agent,
+                       StreamPool* pool,
                        HttpTransaction* transaction)
-    : agent_(agent), pool_(pool),
-      transaction_(transaction), free_transaction_(false),
-      retries_(kDefaultRetries), attempt_(0), redirects_(0),
+    : agent_(agent),
+      pool_(pool),
+      transaction_(transaction),
+      free_transaction_(false),
+      retries_(kDefaultRetries),
+      attempt_(0),
+      redirects_(0),
       redirect_action_(REDIRECT_DEFAULT),
-      uri_form_(URI_DEFAULT), cache_(NULL), cache_state_(CS_READY),
-      resolver_(NULL) {
+      uri_form_(URI_DEFAULT),
+      cache_(nullptr),
+      cache_state_(CS_READY),
+      resolver_(nullptr) {
   base_.notify(this);
-  if (NULL == transaction_) {
+  if (nullptr == transaction_) {
     free_transaction_ = true;
     transaction_ = new HttpTransaction;
   }
 }
 
 HttpClient::~HttpClient() {
-  base_.notify(NULL);
+  base_.notify(nullptr);
   base_.abort(HE_SHUTDOWN);
   if (resolver_) {
     resolver_->Destroy(false);
   }
   release();
   if (free_transaction_)
     delete transaction_;
 }
 
 void HttpClient::reset() {
   server_.Clear();
   request().clear(true);
   response().clear(true);
   context_.reset();
   redirects_ = 0;
   base_.abort(HE_OPERATION_CANCELLED);
 }
 
 void HttpClient::OnResolveResult(AsyncResolverInterface* resolver) {
   if (resolver != resolver_) {
     return;
   }
   int error = resolver_->GetError();
   server_ = resolver_->address();
   resolver_->Destroy(false);
-  resolver_ = NULL;
+  resolver_ = nullptr;
   if (error != 0) {
     LOG(LS_ERROR) << "Error " << error << " resolving name: "
                   << server_;
     onHttpComplete(HM_CONNECT, HE_CONNECT_FAILED);
   } else {
     connect();
   }
 }
 
 void HttpClient::StartDNSLookup() {
@@ skipping 15 matching lines @@
 
 void HttpClient::start() {
   if (base_.mode() != HM_NONE) {
     // call reset() to abort an in-progress request
     RTC_NOTREACHED();
     return;
   }
 
   RTC_DCHECK(!IsCacheActive());
 
-  if (request().hasHeader(HH_TRANSFER_ENCODING, NULL)) {
+  if (request().hasHeader(HH_TRANSFER_ENCODING, nullptr)) {
     // 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;
 
   // If no content has been specified, using length of 0.
   request().setHeader(HH_CONTENT_LENGTH, "0", false);
@@ skipping 24 matching lines @@
     // Convert to relative uri form
     std::string host, path;
     if (request().getRelativeUri(&host, &path)) {
       request().setHeader(HH_HOST, host);
       request().path = path;
     } else {
       LOG(LS_WARNING) << "Couldn't obtain relative uri";
     }
   }
 
-  if ((NULL != cache_) && CheckCache()) {
+  if ((nullptr != cache_) && CheckCache()) {
     return;
   }
 
   connect();
 }
 
 void HttpClient::connect() {
   int stream_err;
   if (server_.IsUnresolvedIP()) {
     StartDNSLookup();
     return;
   }
   StreamInterface* stream = pool_->RequestConnectedStream(server_, &stream_err);
-  if (stream == NULL) {
+  if (stream == nullptr) {
     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 30 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() {
-  RTC_DCHECK(NULL != cache_);
+  RTC_DCHECK(nullptr != 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)) {
@@ skipping 20 matching lines @@
 }
 
 HttpError HttpClient::WriteCacheHeaders(const std::string& id) {
   std::unique_ptr<StreamInterface> stream(
       cache_->WriteResource(id, kCacheHeader));
   if (!stream) {
     LOG_F(LS_ERROR) << "Couldn't open header cache";
     return HE_CACHE;
   }
 
-  if (!HttpWriteCacheHeaders(&transaction_->response, stream.get(), NULL)) {
+  if (!HttpWriteCacheHeaders(&transaction_->response, stream.get(), nullptr)) {
     LOG_F(LS_ERROR) << "Couldn't write header cache";
     return HE_CACHE;
   }
 
   return HE_NONE;
 }
 
 void HttpClient::CompleteCacheFile() {
   // Restore previous response document
   StreamTap* tap = static_cast<StreamTap*>(response().document.release());
   response().document.reset(tap->Detach());
 
   int error;
   StreamResult result = tap->GetTapResult(&error);
 
   // 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() {
-  RTC_DCHECK(NULL != cache_);
+  RTC_DCHECK(nullptr != 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);
 
@@ skipping 150 matching lines @@
     cache_state_ = CS_READY;
     cache_->DeleteResource(GetCacheID(request()));
     // Continue processing response as normal
   }
 
   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))) {
+  if (ShouldRedirect(nullptr) ||
+      ((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);
   }
 
   HttpError error = OnHeaderAvailable(base_.ignore_data(), chunked, data_size);
   if (HE_NONE != error) {
     return error;
   }
 
-  if ((NULL != cache_)
-      && !base_.ignore_data()
-      && HttpShouldCache(*transaction_)) {
+  if ((nullptr != cache_) && !base_.ignore_data() &&
+      HttpShouldCache(*transaction_)) {
     if (BeginCacheFile()) {
       cache_state_ = CS_WRITING;
     }
   }
   return HE_NONE;
 }
 
 void HttpClient::onHttpComplete(HttpMode mode, HttpError err) {
   if (((HE_DISCONNECTED == err) || (HE_CONNECT_FAILED == err)
        || (HE_SOCKET_ERROR == err))
@@ skipping 101 matching lines @@
 }
 
 //////////////////////////////////////////////////////////////////////
 // HttpClientDefault
 //////////////////////////////////////////////////////////////////////
 
 HttpClientDefault::HttpClientDefault(SocketFactory* factory,
                                      const std::string& agent,
                                      HttpTransaction* transaction)
     : ReuseSocketPool(factory ? factory : Thread::Current()->socketserver()),
-      HttpClient(agent, NULL, transaction) {
+      HttpClient(agent, nullptr, transaction) {
   set_pool(this);
 }
 
 //////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc