QUIC - (no behavior change) s/NULL/nullptr/g in .../quic/...

net/quic/quic_http_stream.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/quic_http_stream.h"
 
 #include "base/callback_helpers.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "net/base/io_buffer.h"
@@ skipping 12 matching lines @@
 
 namespace net {
 
 static const size_t kHeaderBufInitialSize = 4096;
 
 QuicHttpStream::QuicHttpStream(const base::WeakPtr<QuicClientSession>& session)
     : next_state_(STATE_NONE),
       session_(session),
       session_error_(OK),
       was_handshake_confirmed_(session->IsCryptoHandshakeConfirmed()),
-      stream_(NULL),
-      request_info_(NULL),
-      request_body_stream_(NULL),
+      stream_(nullptr),
+      request_info_(nullptr),
+      request_body_stream_(nullptr),
       priority_(MINIMUM_PRIORITY),
-      response_info_(NULL),
+      response_info_(nullptr),
       response_status_(OK),
       response_headers_received_(false),
       read_buf_(new GrowableIOBuffer()),
       closed_stream_received_bytes_(0),
       user_buffer_len_(0),
       weak_factory_(this) {
   DCHECK(session_);
   session_->AddObserver(this);
 }
 
@@ skipping 100 matching lines @@
   if (!request_body_stream_)
     return UploadProgress();
 
   return UploadProgress(request_body_stream_->position(),
                         request_body_stream_->size());
 }
 
 int QuicHttpStream::ReadResponseHeaders(const CompletionCallback& callback) {
   CHECK(!callback.is_null());
 
-  if (stream_ == NULL)
+  if (stream_ == nullptr)
     return response_status_;
 
   // Check if we already have the response headers. If so, return synchronously.
   if (response_headers_received_)
     return OK;
 
   // Still waiting for the response, return IO_PENDING.
   CHECK(callback_.is_null());
   callback_ = callback;
   return ERR_IO_PENDING;
@@ skipping 40 matching lines @@
   callback_ = callback;
   user_buffer_ = buf;
   user_buffer_len_ = buf_len;
   return ERR_IO_PENDING;
 }
 
 void QuicHttpStream::Close(bool not_reusable) {
   // Note: the not_reusable flag has no meaning for SPDY streams.
   if (stream_) {
     closed_stream_received_bytes_ = stream_->stream_bytes_read();
-    stream_->SetDelegate(NULL);
+    stream_->SetDelegate(nullptr);
     stream_->Reset(QUIC_STREAM_CANCELLED);
-    stream_ = NULL;
+    stream_ = nullptr;
     response_status_ = was_handshake_confirmed_ ?
         ERR_CONNECTION_CLOSED : ERR_QUIC_HANDSHAKE_FAILED;
   }
 }
 
 HttpStream* QuicHttpStream::RenewStreamForAuth() {
-  return NULL;
+  return nullptr;
 }
 
 bool QuicHttpStream::IsResponseBodyComplete() const {
   return next_state_ == STATE_OPEN && !stream_;
 }
 
 bool QuicHttpStream::CanFindEndOfResponse() const {
   return true;
 }
 
@@ skipping 75 matching lines @@
 
   if (length <= user_buffer_len_) {
     memcpy(user_buffer_->data(), data, length);
   } else {
     memcpy(user_buffer_->data(), data, user_buffer_len_);
     int delta = length - user_buffer_len_;
     BufferResponseBody(data + user_buffer_len_, delta);
     length = user_buffer_len_;
   }
 
-  user_buffer_ = NULL;
+  user_buffer_ = nullptr;
   user_buffer_len_ = 0;
   DoCallback(length);
   return OK;
 }
 
 void QuicHttpStream::OnClose(QuicErrorCode error) {
   if (error != QUIC_NO_ERROR) {
     response_status_ = was_handshake_confirmed_ ?
         ERR_QUIC_PROTOCOL_ERROR : ERR_QUIC_HANDSHAKE_FAILED;
   } else if (!response_headers_received_) {
     response_status_ = ERR_ABORTED;
   }
 
   closed_stream_received_bytes_ = stream_->stream_bytes_read();
-  stream_ = NULL;
+  stream_ = nullptr;
   if (!callback_.is_null())
     DoCallback(response_status_);
 }
 
 void QuicHttpStream::OnError(int error) {
-  stream_ = NULL;
+  stream_ = nullptr;
   response_status_ = was_handshake_confirmed_ ?
       error : ERR_QUIC_HANDSHAKE_FAILED;
   if (!callback_.is_null())
     DoCallback(response_status_);
 }
 
 bool QuicHttpStream::HasSendHeadersComplete() {
   return next_state_ > STATE_SEND_HEADERS_COMPLETE;
 }
 
@@ skipping 71 matching lines @@
   stream_net_log_.AddEvent(
       NetLog::TYPE_HTTP_TRANSACTION_QUIC_SEND_REQUEST_HEADERS,
       base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
                  priority_));
   // Also log to the QuicSession's net log.
   stream_->net_log().AddEvent(
       NetLog::TYPE_QUIC_HTTP_STREAM_SEND_REQUEST_HEADERS,
       base::Bind(&QuicRequestNetLogCallback, stream_->id(), &request_headers_,
                  priority_));
 
-  bool has_upload_data = request_body_stream_ != NULL;
+  bool has_upload_data = request_body_stream_ != nullptr;
 
   next_state_ = STATE_SEND_HEADERS_COMPLETE;
-  int rv = stream_->WriteHeaders(request_headers_, !has_upload_data, NULL);
+  int rv = stream_->WriteHeaders(request_headers_, !has_upload_data, nullptr);
   request_headers_.clear();
   return rv;
 }
 
 int QuicHttpStream::DoSendHeadersComplete(int rv) {
   if (rv < 0)
     return rv;
 
   next_state_ = request_body_stream_ ?
       STATE_READ_REQUEST_BODY : STATE_OPEN;
@@ skipping 105 matching lines @@
 
 void QuicHttpStream::BufferResponseBody(const char* data, int length) {
   if (length == 0)
     return;
   IOBufferWithSize* io_buffer = new IOBufferWithSize(length);
   memcpy(io_buffer->data(), data, length);
   response_body_.push_back(make_scoped_refptr(io_buffer));
 }
 
 }  // namespace net