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

net/quic/quic_client_session.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_client_session.h"
 
 #include "base/callback_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
@@ skipping 76 matching lines @@
   NUM_HANDSHAKE_STATES = 4
 };
 
 void RecordHandshakeState(HandshakeState state) {
   UMA_HISTOGRAM_ENUMERATION("Net.QuicHandshakeState", state,
                             NUM_HANDSHAKE_STATES);
 }
 
 }  // namespace
 
-QuicClientSession::StreamRequest::StreamRequest() : stream_(NULL) {}
+QuicClientSession::StreamRequest::StreamRequest() : stream_(nullptr) {}
 
 QuicClientSession::StreamRequest::~StreamRequest() {
   CancelRequest();
 }
 
 int QuicClientSession::StreamRequest::StartRequest(
     const base::WeakPtr<QuicClientSession>& session,
     QuicReliableClientStream** stream,
     const CompletionCallback& callback) {
   session_ = session;
@@ skipping 81 matching lines @@
 
   while (!streams()->empty() ||
          !observers_.empty() ||
          !stream_requests_.empty()) {
     // The session must be closed before it is destroyed.
     DCHECK(streams()->empty());
     CloseAllStreams(ERR_UNEXPECTED);
     DCHECK(observers_.empty());
     CloseAllObservers(ERR_UNEXPECTED);
 
-    connection()->set_debug_visitor(NULL);
+    connection()->set_debug_visitor(nullptr);
     net_log_.EndEvent(NetLog::TYPE_QUIC_SESSION);
 
     while (!stream_requests_.empty()) {
       StreamRequest* request = stream_requests_.front();
       stream_requests_.pop_front();
       request->OnRequestCompleteFailure(ERR_ABORTED);
     }
   }
 
   if (connection()->connected()) {
@@ skipping 144 matching lines @@
   StreamRequestQueue::iterator it =
       std::find(stream_requests_.begin(), stream_requests_.end(), request);
   if (it != stream_requests_.end()) {
     it = stream_requests_.erase(it);
   }
 }
 
 QuicReliableClientStream* QuicClientSession::CreateOutgoingDataStream() {
   if (!crypto_stream_->encryption_established()) {
     DVLOG(1) << "Encryption not active so no outgoing stream created.";
-    return NULL;
+    return nullptr;
   }
   if (GetNumOpenStreams() >= get_max_open_streams()) {
     DVLOG(1) << "Failed to create a new outgoing stream. "
              << "Already " << GetNumOpenStreams() << " open.";
-    return NULL;
+    return nullptr;
   }
   if (goaway_received()) {
     DVLOG(1) << "Failed to create a new outgoing stream. "
              << "Already received goaway.";
-    return NULL;
+    return nullptr;
   }
   if (going_away_) {
     RecordUnexpectedOpenStreams(CREATE_OUTGOING_RELIABLE_STREAM);
-    return NULL;
+    return nullptr;
   }
   return CreateOutgoingReliableStreamImpl();
 }
 
 QuicReliableClientStream*
 QuicClientSession::CreateOutgoingReliableStreamImpl() {
   DCHECK(connection()->connected());
   QuicReliableClientStream* stream =
       new QuicReliableClientStream(GetNextStreamId(), this, net_log_);
   ActivateStream(stream);
@@ skipping 114 matching lines @@
     return true;
   }
 
   return SpdySession::CanPool(transport_security_state_, ssl_info,
                               server_host_port_.host(), hostname);
 }
 
 QuicDataStream* QuicClientSession::CreateIncomingDataStream(
     QuicStreamId id) {
   DLOG(ERROR) << "Server push not supported";
-  return NULL;
+  return nullptr;
 }
 
 void QuicClientSession::CloseStream(QuicStreamId stream_id) {
   ReliableQuicStream* stream = GetStream(stream_id);
   if (stream) {
     logger_->UpdateReceivedFrameCounts(
         stream_id, stream->num_frames_received(),
         stream->num_duplicate_frames_received());
   }
   QuicSession::CloseStream(stream_id);
@@ skipping 339 matching lines @@
     return;
 
   // TODO(rch): re-enable this code once beta is cut.
   //  if (stream_factory_)
   //    stream_factory_->OnSessionConnectTimeout(this);
   //  CloseAllStreams(ERR_QUIC_HANDSHAKE_FAILED);
   //  DCHECK_EQ(0u, GetNumOpenStreams());
 }
 
 }  // namespace net