Replace NULL with nullptr or null in webrtc/base/.

webrtc/base/httpbase.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 158 matching lines @@
       }
       return ProcessHeader(line, nlen, value, vlen, error);
     } else {
       state_ = chunked_ ? ST_CHUNKSIZE : ST_DATA;
       return ProcessHeaderComplete(chunked_, data_size_, error);
     }
     break;
 
   case ST_CHUNKSIZE:
     if (len > 0) {
-      char* ptr = NULL;
+      char* ptr = nullptr;
       data_size_ = strtoul(line, &ptr, 16);
       if (ptr != line + len) {
         *error = HE_PROTOCOL;
         return PR_COMPLETE;
       }
       state_ = (data_size_ == 0) ? ST_TRAILERS : ST_DATA;
     } else {
       *error = HE_PROTOCOL;
       return PR_COMPLETE;
     }
@@ skipping 48 matching lines @@
   StreamResult DoReserve(size_t size, int* error) override {
     return (buffer_length_ >= size) ? SR_SUCCESS : SR_BLOCK;
   }
 };
 
 class HttpBase::DocumentStream : public StreamInterface {
 public:
   DocumentStream(HttpBase* base) : base_(base), error_(HE_DEFAULT) { }
 
   StreamState GetState() const override {
-    if (NULL == base_)
+    if (nullptr == base_)
       return SS_CLOSED;
     if (HM_RECV == base_->mode_)
       return SS_OPEN;
     return SS_OPENING;
   }
 
   StreamResult Read(void* buffer,
                     size_t buffer_len,
                     size_t* read,
                     int* error) override {
@@ skipping 76 matching lines @@
       return false;
     size_t data_size = base_->GetDataRemaining();
     if (SIZE_UNKNOWN == data_size)
       return false;
     if (size)
       *size = data_size;
     return true;
   }
 
   HttpBase* Disconnect(HttpError error) {
-    RTC_DCHECK(NULL != base_);
-    RTC_DCHECK(NULL != base_->doc_stream_);
+    RTC_DCHECK(nullptr != base_);
+    RTC_DCHECK(nullptr != base_->doc_stream_);
     HttpBase* base = base_;
-    base_->doc_stream_ = NULL;
-    base_ = NULL;
+    base_->doc_stream_ = nullptr;
+    base_ = nullptr;
     error_ = error;
     return base;
   }
 
 private:
   HttpBase* base_;
   HttpError error_;
 };
 
 //////////////////////////////////////////////////////////////////////
 // HttpBase
 //////////////////////////////////////////////////////////////////////
 
-HttpBase::HttpBase() : mode_(HM_NONE), data_(NULL), notify_(NULL),
-                       http_stream_(NULL), doc_stream_(NULL) {
-}
+HttpBase::HttpBase()
+    : mode_(HM_NONE),
+      data_(nullptr),
+      notify_(nullptr),
+      http_stream_(nullptr),
+      doc_stream_(nullptr) {}
 
 HttpBase::~HttpBase() {
   RTC_DCHECK(HM_NONE == mode_);
 }
 
 bool
 HttpBase::isConnected() const {
-  return (http_stream_ != NULL) && (http_stream_->GetState() == SS_OPEN);
+  return (http_stream_ != nullptr) && (http_stream_->GetState() == SS_OPEN);
 }
 
 bool
 HttpBase::attach(StreamInterface* stream) {
-  if ((mode_ != HM_NONE) || (http_stream_ != NULL) || (stream == NULL)) {
+  if ((mode_ != HM_NONE) || (http_stream_ != nullptr) || (stream == nullptr)) {
     RTC_NOTREACHED();
     return false;
   }
   http_stream_ = stream;
   http_stream_->SignalEvent.connect(this, &HttpBase::OnHttpStreamEvent);
   mode_ = (http_stream_->GetState() == SS_OPENING) ? HM_CONNECT : HM_NONE;
   return true;
 }
 
 StreamInterface*
 HttpBase::detach() {
   RTC_DCHECK(HM_NONE == mode_);
   if (mode_ != HM_NONE) {
-    return NULL;
+    return nullptr;
   }
   StreamInterface* stream = http_stream_;
-  http_stream_ = NULL;
+  http_stream_ = nullptr;
   if (stream) {
     stream->SignalEvent.disconnect(this);
   }
   return stream;
 }
 
 void
 HttpBase::send(HttpData* data) {
   RTC_DCHECK(HM_NONE == mode_);
   if (mode_ != HM_NONE) {
@@ skipping 49 matching lines @@
   if (doc_stream_) {
     doc_stream_->SignalEvent(doc_stream_, SE_OPEN | SE_READ, 0);
   } else {
     read_and_process_data();
   }
 }
 
 void
 HttpBase::abort(HttpError err) {
   if (mode_ != HM_NONE) {
-    if (http_stream_ != NULL) {
+    if (http_stream_ != nullptr) {
       http_stream_->Close();
     }
     do_complete(err);
   }
 }
 
 StreamInterface* HttpBase::GetDocumentStream() {
   if (doc_stream_)
-    return NULL;
+    return nullptr;
   doc_stream_ = new DocumentStream(this);
   return doc_stream_;
 }
 
 HttpError HttpBase::HandleStreamClose(int error) {
-  if (http_stream_ != NULL) {
+  if (http_stream_ != nullptr) {
     http_stream_->Close();
   }
   if (error == 0) {
     if ((mode_ == HM_RECV) && is_valid_end_of_input()) {
       return HE_NONE;
     } else {
       return HE_DISCONNECTED;
     }
   } else if (error == SOCKET_EACCES) {
     return HE_AUTH;
   } else if (error == SEC_E_CERT_EXPIRED) {
     return HE_CERTIFICATE_EXPIRED;
   }
   LOG_F(LS_ERROR) << "(" << error << ")";
   return (HM_CONNECT == mode_) ? HE_CONNECT_FAILED : HE_SOCKET_ERROR;
 }
 
 bool HttpBase::DoReceiveLoop(HttpError* error) {
   RTC_DCHECK(HM_RECV == mode_);
-  RTC_DCHECK(NULL != error);
+  RTC_DCHECK(nullptr != error);
 
   // Do to the latency between receiving read notifications from
   // pseudotcpchannel, we rely on repeated calls to read in order to acheive
   // ideal throughput.  The number of reads is limited to prevent starving
   // the caller.
 
   size_t loop_count = 0;
   const size_t kMaxReadCount = 20;
   bool process_requires_more_data = false;
   do {
@@ skipping 219 matching lines @@
 }
 
 void
 HttpBase::do_complete(HttpError err) {
   RTC_DCHECK(mode_ != HM_NONE);
   HttpMode mode = mode_;
   mode_ = HM_NONE;
   if (data_ && data_->document) {
     data_->document->SignalEvent.disconnect(this);
   }
-  data_ = NULL;
+  data_ = nullptr;
   if ((HM_RECV == mode) && doc_stream_) {
     RTC_DCHECK(HE_NONE !=
                err);  // We should have Disconnected doc_stream_ already.
     DocumentStream* ds = doc_stream_;
     ds->Disconnect(err);
     ds->SignalEvent(ds, SE_CLOSE, err);
   }
   if (notify_) {
     notify_->onHttpComplete(mode, err);
   }
@@ skipping 76 matching lines @@
   return PR_CONTINUE;
 }
 
 HttpParser::ProcessResult
 HttpBase::ProcessHeaderComplete(bool chunked, size_t& data_size,
                                 HttpError* error) {
   StreamInterface* old_docstream = doc_stream_;
   if (notify_) {
     *error = notify_->onHttpHeaderComplete(chunked, data_size);
     // The request must not be aborted as a result of this callback.
-    RTC_DCHECK(NULL != data_);
+    RTC_DCHECK(nullptr != data_);
   }
   if ((HE_NONE == *error) && data_->document) {
     data_->document->SignalEvent.connect(this, &HttpBase::OnDocumentEvent);
   }
   if (HE_NONE != *error) {
     return PR_COMPLETE;
   }
   if (old_docstream != doc_stream_) {
     // Break out of Process loop, since our I/O model just changed.
     return PR_BLOCK;
@@ skipping 26 matching lines @@
   }
 }
 
 void
 HttpBase::OnComplete(HttpError err) {
   LOG_F(LS_VERBOSE);
   do_complete(err);
 }
 
 } // namespace rtc