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

net/quic/quic_stream_factory.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_stream_factory.h"
 
 #include <set>
 
 #include "base/cpu.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 216 matching lines @@
                             const BoundNetLog& net_log)
     : io_state_(STATE_RESOLVE_HOST),
       factory_(factory),
       host_resolver_(host_resolver),
       server_id_(host_port_pair, is_https, privacy_mode),
       is_post_(method == "POST"),
       was_alternate_protocol_recently_broken_(
           was_alternate_protocol_recently_broken),
       server_info_(server_info),
       net_log_(net_log),
-      session_(NULL),
+      session_(nullptr),
       weak_factory_(this) {}
 
 QuicStreamFactory::Job::Job(QuicStreamFactory* factory,
                             HostResolver* host_resolver,
                             QuicClientSession* session,
                             QuicServerId server_id)
     : io_state_(STATE_RESUME_CONNECT),
       factory_(factory),
       host_resolver_(host_resolver),  // unused
       server_id_(server_id),
@@ skipping 163 matching lines @@
 int QuicStreamFactory::Job::DoConnectComplete(int rv) {
   if (rv != OK)
     return rv;
 
   DCHECK(!factory_->HasActiveSession(server_id_));
   // There may well now be an active session for this IP.  If so, use the
   // existing session instead.
   AddressList address(session_->connection()->peer_address());
   if (factory_->OnResolution(server_id_, address)) {
     session_->connection()->SendConnectionClose(QUIC_CONNECTION_IP_POOLED);
-    session_ = NULL;
+    session_ = nullptr;
     return OK;
   }
 
   factory_->ActivateSession(server_id_, session_);
 
   return OK;
 }
 
 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
     : factory_(factory) {}
@@ skipping 13 matching lines @@
   DCHECK(callback_.is_null());
   DCHECK(factory_);
   int rv = factory_->Create(host_port_pair, is_https, privacy_mode, method,
                             net_log, this);
   if (rv == ERR_IO_PENDING) {
     host_port_pair_ = host_port_pair;
     is_https_ = is_https;
     net_log_ = net_log;
     callback_ = callback;
   } else {
-    factory_ = NULL;
+    factory_ = nullptr;
   }
   if (rv == OK)
     DCHECK(stream_);
   return rv;
 }
 
 void QuicStreamRequest::set_stream(scoped_ptr<QuicHttpStream> stream) {
   DCHECK(stream);
   stream_ = stream.Pass();
 }
 
 void QuicStreamRequest::OnRequestComplete(int rv) {
-  factory_ = NULL;
+  factory_ = nullptr;
   callback_.Run(rv);
 }
 
 scoped_ptr<QuicHttpStream> QuicStreamRequest::ReleaseStream() {
   DCHECK(stream_);
   return stream_.Pass();
 }
 
 QuicStreamFactory::QuicStreamFactory(
     HostResolver* host_resolver,
@@ skipping 10 matching lines @@
     const QuicVersionVector& supported_versions,
     bool enable_port_selection,
     bool always_require_handshake_confirmation,
     bool disable_connection_pooling,
     const QuicTagVector& connection_options)
     : require_confirmation_(true),
       host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       http_server_properties_(http_server_properties),
       transport_security_state_(transport_security_state),
-      quic_server_info_factory_(NULL),
+      quic_server_info_factory_(nullptr),
       quic_crypto_client_stream_factory_(quic_crypto_client_stream_factory),
       random_generator_(random_generator),
       clock_(clock),
       max_packet_length_(max_packet_length),
       config_(InitializeQuicConfig(connection_options)),
       supported_versions_(supported_versions),
       enable_port_selection_(enable_port_selection),
       always_require_handshake_confirmation_(
           always_require_handshake_confirmation),
       disable_connection_pooling_(disable_connection_pooling),
@@ skipping 48 matching lines @@
     return OK;
   }
 
   if (HasActiveJob(server_id)) {
     Job* job = active_jobs_[server_id];
     active_requests_[request] = job;
     job_requests_map_[job].insert(request);
     return ERR_IO_PENDING;
   }
 
-  QuicServerInfo* quic_server_info = NULL;
+  QuicServerInfo* quic_server_info = nullptr;
   if (quic_server_info_factory_) {
     QuicCryptoClientConfig::CachedState* cached =
         crypto_config_.LookupOrCreate(server_id);
     DCHECK(cached);
     if (cached->IsEmpty()) {
       quic_server_info = quic_server_info_factory_->GetForServer(server_id);
     }
   }
   bool was_alternate_protocol_recently_broken =
       http_server_properties_ &&
@@ skipping 67 matching lines @@
     // profile which can not be deleted via callbacks.
     request->OnRequestComplete(rv);
   }
   active_jobs_.erase(job->server_id());
   job_requests_map_.erase(job);
   delete job;
   return;
 }
 
 // Returns a newly created QuicHttpStream owned by the caller, if a
-// matching session already exists.  Returns NULL otherwise.
+// matching session already exists.  Returns nullptr otherwise.
 scoped_ptr<QuicHttpStream> QuicStreamFactory::CreateIfSessionExists(
     const QuicServerId& server_id,
     const BoundNetLog& net_log) {
   if (!HasActiveSession(server_id)) {
     DVLOG(1) << "No active session";
     return scoped_ptr<QuicHttpStream>();
   }
 
   QuicClientSession* session = active_sessions_[server_id];
   DCHECK(session);
@@ skipping 235 matching lines @@
   config.SetInitialCongestionWindowToSend(
       server_id.is_https() ? kServerSecureInitialCongestionWindow
                            : kServerInecureInitialCongestionWindow);
   config.SetInitialFlowControlWindowToSend(kInitialReceiveWindowSize);
   config.SetInitialStreamFlowControlWindowToSend(kInitialReceiveWindowSize);
   config.SetInitialSessionFlowControlWindowToSend(kInitialReceiveWindowSize);
   if (http_server_properties_) {
     const HttpServerProperties::NetworkStats* stats =
         http_server_properties_->GetServerNetworkStats(
             server_id.host_port_pair());
-    if (stats != NULL) {
+    if (stats != nullptr) {
       config.SetInitialRoundTripTimeUsToSend(stats->srtt.InMicroseconds());
     }
   }
 
   *session = new QuicClientSession(
       connection, socket.Pass(), this, transport_security_state_,
       server_info.Pass(), config,
       base::MessageLoop::current()->message_loop_proxy().get(),
       net_log.net_log());
   all_sessions_[*session] = server_id;  // owning pointer
   (*session)->InitializeSession(server_id,  &crypto_config_,
                                 quic_crypto_client_stream_factory_);
   bool closed_during_initialize =
       !ContainsKey(all_sessions_, *session) ||
       !(*session)->connection()->connected();
   UMA_HISTOGRAM_BOOLEAN("Net.QuicSession.ClosedDuringInitializeSession",
                         closed_during_initialize);
   if (closed_during_initialize) {
     DLOG(DFATAL) << "Session closed during initialize";
-    *session = NULL;
+    *session = nullptr;
     return ERR_CONNECTION_CLOSED;
   }
   return OK;
 }
 
 bool QuicStreamFactory::HasActiveJob(const QuicServerId& key) const {
   return ContainsKey(active_jobs_, key);
 }
 
 void QuicStreamFactory::ActivateSession(
@@ skipping 82 matching lines @@
   http_server_properties_->ClearAlternateProtocol(server);
   http_server_properties_->SetAlternateProtocol(
       server, alternate.port, alternate.protocol, 1);
   DCHECK_EQ(QUIC,
             http_server_properties_->GetAlternateProtocol(server).protocol);
   DCHECK(http_server_properties_->WasAlternateProtocolRecentlyBroken(
       server));
 }
 
 }  // namespace net