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

net/tools/quic/quic_dispatcher.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_dispatcher.h"
 
 #include <errno.h>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 174 matching lines @@
                                PacketWriterFactory* packet_writer_factory,
                                EpollServer* epoll_server)
     : config_(config),
       crypto_config_(crypto_config),
       delete_sessions_alarm_(new DeleteSessionsAlarm(this)),
       epoll_server_(epoll_server),
       helper_(new QuicEpollConnectionHelper(epoll_server_)),
       packet_writer_factory_(packet_writer_factory),
       connection_writer_factory_(this),
       supported_versions_(supported_versions),
-      current_packet_(NULL),
+      current_packet_(nullptr),
       framer_(supported_versions, /*unused*/ QuicTime::Zero(), true),
       framer_visitor_(new QuicFramerVisitor(this)) {
   framer_.set_visitor(framer_visitor_.get());
 }
 
 QuicDispatcher::~QuicDispatcher() {
   STLDeleteValues(&session_map_);
   STLDeleteElements(&closed_session_list_);
 }
 
 void QuicDispatcher::Initialize(int fd) {
-  DCHECK(writer_ == NULL);
+  DCHECK(writer_ == nullptr);
   writer_.reset(CreateWriter(fd));
   time_wait_list_manager_.reset(CreateQuicTimeWaitListManager());
 }
 
 void QuicDispatcher::ProcessPacket(const IPEndPoint& server_address,
                                    const IPEndPoint& client_address,
                                    const QuicEncryptedPacket& packet) {
   current_server_address_ = server_address;
   current_client_address_ = client_address;
   current_packet_ = &packet;
   // ProcessPacket will cause the packet to be dispatched in
   // OnUnauthenticatedPublicHeader, or sent to the time wait list manager
   // in OnAuthenticatedHeader.
   framer_.ProcessPacket(packet);
   // TODO(rjshade): Return a status describing if/why a packet was dropped,
   //                and log somehow.  Maybe expose as a varz.
 }
 
 bool QuicDispatcher::OnUnauthenticatedPublicHeader(
     const QuicPacketPublicHeader& header) {
-  QuicSession* session = NULL;
+  QuicSession* session = nullptr;
 
   QuicConnectionId connection_id = header.connection_id;
   SessionMap::iterator it = session_map_.find(connection_id);
   if (it == session_map_.end()) {
     if (header.reset_flag) {
       return false;
     }
     if (time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id)) {
       return HandlePacketForTimeWait(header);
     }
 
     // Ensure the packet has a version negotiation bit set before creating a new
     // session for it.  All initial packets for a new connection are required to
     // have the flag set.  Otherwise it may be a stray packet.
     if (header.version_flag) {
       session = CreateQuicSession(connection_id, current_server_address_,
                                   current_client_address_);
     }
 
-    if (session == NULL) {
+    if (session == nullptr) {
       DVLOG(1) << "Failed to create session for " << connection_id;
       // Add this connection_id fo the time-wait state, to safely reject future
       // packets.
 
       if (header.version_flag &&
           !framer_.IsSupportedVersion(header.versions.front())) {
         // TODO(ianswett): Produce a no-version version negotiation packet.
         return false;
       }
 
       // Use the version in the packet if possible, otherwise assume the latest.
       QuicVersion version = header.version_flag ? header.versions.front() :
           supported_versions_.front();
-      time_wait_list_manager_->AddConnectionIdToTimeWait(
-          connection_id, version, NULL);
+      time_wait_list_manager_->AddConnectionIdToTimeWait(connection_id, version,
+                                                         nullptr);
       DCHECK(time_wait_list_manager_->IsConnectionIdInTimeWait(connection_id));
       return HandlePacketForTimeWait(header);
     }
     DVLOG(1) << "Created new session for " << connection_id;
     session_map_.insert(make_pair(connection_id, session));
   } else {
     session = it->second;
   }
 
   session->connection()->ProcessUdpPacket(
@@ skipping 138 matching lines @@
   framer_.set_version(time_wait_list_manager_->GetQuicVersionFromConnectionId(
       header.connection_id));
 
   // Continue parsing the packet to extract the sequence number.  Then
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 }  // namespace tools
 }  // namespace net