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

net/tools/quic/quic_client.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/tools/quic/quic_client.h"
 
 #include <errno.h>
 #include <netinet/in.h>
 #include <string.h>
 #include <sys/epoll.h>
@@ skipping 217 matching lines @@
   fd_ = -1;
   initialized_ = false;
 }
 
 void QuicClient::SendRequestsAndWaitForResponse(
     const base::CommandLine::StringVector& args) {
   for (size_t i = 0; i < args.size(); ++i) {
     BalsaHeaders headers;
     headers.SetRequestFirstlineFromStringPieces("GET", args[i], "HTTP/1.1");
     QuicSpdyClientStream* stream = CreateReliableClientStream();
-    DCHECK(stream != NULL);
+    DCHECK(stream != nullptr);
     stream->SendRequest(headers, "", true);
     stream->set_visitor(this);
   }
 
   while (WaitForEvents()) {}
 }
 
 QuicSpdyClientStream* QuicClient::CreateReliableClientStream() {
   if (!connected()) {
-    return NULL;
+    return nullptr;
   }
 
   return session_->CreateOutgoingDataStream();
 }
 
 void QuicClient::WaitForStreamToClose(QuicStreamId id) {
   DCHECK(connected());
 
   while (connected() && !session_->IsClosedStream(id)) {
     epoll_server_->WaitForEventsAndExecuteCallbacks();
@@ skipping 27 matching lines @@
     session_->connection()->OnCanWrite();
   }
   if (event->in_events & EPOLLERR) {
     DVLOG(1) << "Epollerr";
   }
 }
 
 void QuicClient::OnClose(QuicDataStream* stream) {
   QuicSpdyClientStream* client_stream =
       static_cast<QuicSpdyClientStream*>(stream);
-  if (response_listener_.get() != NULL) {
+  if (response_listener_.get() != nullptr) {
     response_listener_->OnCompleteResponse(
         stream->id(), client_stream->headers(), client_stream->data());
   }
 
   if (!print_response_) {
     return;
   }
 
   const BalsaHeaders& headers = client_stream->headers();
   printf("%s\n", headers.first_line().as_string().c_str());
@@ skipping 21 matching lines @@
 
 QuicPacketWriter* QuicClient::CreateQuicPacketWriter() {
   return new QuicDefaultPacketWriter(fd_);
 }
 
 int QuicClient::ReadPacket(char* buffer,
                            int buffer_len,
                            IPEndPoint* server_address,
                            IPAddressNumber* client_ip) {
   return QuicSocketUtils::ReadPacket(
-      fd_, buffer, buffer_len, overflow_supported_ ? &packets_dropped_ : NULL,
-      client_ip, server_address);
+      fd_, buffer, buffer_len,
+      overflow_supported_ ? &packets_dropped_ : nullptr, client_ip,
+      server_address);
 }
 
 bool QuicClient::ReadAndProcessPacket() {
   // Allocate some extra space so we can send an error if the server goes over
   // the limit.
   char buf[2 * kMaxPacketSize];
 
   IPEndPoint server_address;
   IPAddressNumber client_ip;
 
   int bytes_read = ReadPacket(buf, arraysize(buf), &server_address, &client_ip);
 
   if (bytes_read < 0) {
     return false;
   }
 
   QuicEncryptedPacket packet(buf, bytes_read, false);
 
   IPEndPoint client_address(client_ip, client_address_.port());
   session_->connection()->ProcessUdpPacket(
       client_address, server_address, packet);
   return true;
 }
 
 }  // namespace tools
 }  // namespace net