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

net/tools/quic/test_tools/quic_test_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/test_tools/quic_test_client.h"
 
 #include "base/time/time.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verify_result.h"
@@ skipping 64 matching lines @@
  private:
   string common_name_;
 };
 
 }  // anonymous namespace
 
 BalsaHeaders* MungeHeaders(const BalsaHeaders* const_headers,
                            bool secure) {
   StringPiece uri = const_headers->request_uri();
   if (uri.empty()) {
-    return NULL;
+    return nullptr;
   }
   if (const_headers->request_method() == "CONNECT") {
-    return NULL;
+    return nullptr;
   }
   BalsaHeaders* headers = new BalsaHeaders;
   headers->CopyFrom(*const_headers);
   if (!uri.starts_with("https://") &&
       !uri.starts_with("http://")) {
     // If we have a relative URL, set some defaults.
     string full_uri = secure ? "https://www.google.com" :
                                "http://www.google.com";
     full_uri.append(uri.as_string());
     headers->SetRequestUri(full_uri);
   }
   return headers;
 }
 
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicVersionVector& supported_versions,
     EpollServer* epoll_server)
     : QuicClient(server_address,
                  server_id,
                  supported_versions,
                  false,
                  epoll_server),
       override_connection_id_(0),
-      test_writer_(NULL) {}
+      test_writer_(nullptr) {}
 
 MockableQuicClient::MockableQuicClient(
     IPEndPoint server_address,
     const QuicServerId& server_id,
     const QuicConfig& config,
     const QuicVersionVector& supported_versions,
     EpollServer* epoll_server)
     : QuicClient(server_address,
                  server_id,
                  supported_versions,
                  false,
                  config,
                  epoll_server),
       override_connection_id_(0),
-      test_writer_(NULL) {}
+      test_writer_(nullptr) {}
 
 MockableQuicClient::~MockableQuicClient() {
   if (connected()) {
     Disconnect();
   }
 }
 
 QuicPacketWriter* MockableQuicClient::CreateQuicPacketWriter() {
   QuicPacketWriter* writer = QuicClient::CreateQuicPacketWriter();
   if (!test_writer_) {
     return writer;
   }
   test_writer_->set_writer(writer);
   return test_writer_;
 }
 
 QuicConnectionId MockableQuicClient::GenerateConnectionId() {
   return override_connection_id_ ? override_connection_id_
       : QuicClient::GenerateConnectionId();
 }
 
 // Takes ownership of writer.
 void MockableQuicClient::UseWriter(QuicPacketWriterWrapper* writer) {
-  CHECK(test_writer_ == NULL);
+  CHECK(test_writer_ == nullptr);
   test_writer_ = writer;
 }
 
 void MockableQuicClient::UseConnectionId(QuicConnectionId connection_id) {
   override_connection_id_ = connection_id;
 }
 
 QuicTestClient::QuicTestClient(IPEndPoint server_address,
                                const string& server_hostname,
                                const QuicVersionVector& supported_versions)
@@ skipping 37 matching lines @@
                                  supported_versions,
                                  &epoll_server_)) {
   Initialize(secure);
 }
 
 QuicTestClient::QuicTestClient() {
 }
 
 QuicTestClient::~QuicTestClient() {
   if (stream_) {
-    stream_->set_visitor(NULL);
+    stream_->set_visitor(nullptr);
   }
 }
 
 void QuicTestClient::Initialize(bool secure) {
   priority_ = 3;
   connect_attempted_ = false;
   secure_ = secure;
   auto_reconnect_ = false;
   buffer_body_ = true;
   fec_policy_ = FEC_PROTECT_OPTIONAL;
-  proof_verifier_ = NULL;
+  proof_verifier_ = nullptr;
   ClearPerRequestState();
   ExpectCertificates(secure_);
 }
 
 void QuicTestClient::ExpectCertificates(bool on) {
   if (on) {
     proof_verifier_ = new RecordingProofVerifier;
     client_->SetProofVerifier(proof_verifier_);
   } else {
-    proof_verifier_ = NULL;
-    client_->SetProofVerifier(NULL);
+    proof_verifier_ = nullptr;
+    client_->SetProofVerifier(nullptr);
   }
 }
 
 void QuicTestClient::SetUserAgentID(const string& user_agent_id) {
   client_->SetUserAgentID(user_agent_id);
 }
 
 ssize_t QuicTestClient::SendRequest(const string& uri) {
   HTTPMessage message(HttpConstants::HTTP_1_1,
                       HttpConstants::GET,
                       uri);
   return SendMessage(message);
 }
 
 ssize_t QuicTestClient::SendMessage(const HTTPMessage& message) {
-  stream_ = NULL;  // Always force creation of a stream for SendMessage.
+  stream_ = nullptr;  // Always force creation of a stream for SendMessage.
 
   // If we're not connected, try to find an sni hostname.
   if (!connected()) {
     GURL url(message.headers()->request_uri().as_string());
     if (!url.host().empty()) {
       client_->set_server_id(
           QuicServerId(url.host(),
                        url.EffectiveIntPort(),
                        url.SchemeIs("https"),
                        PRIVACY_MODE_DISABLED));
@@ skipping 64 matching lines @@
   WaitForResponse();
   return response_;
 }
 
 QuicSpdyClientStream* QuicTestClient::GetOrCreateStream() {
   if (!connect_attempted_ || auto_reconnect_) {
     if (!connected()) {
       Connect();
     }
     if (!connected()) {
-      return NULL;
+      return nullptr;
     }
   }
   if (!stream_) {
     stream_ = client_->CreateReliableClientStream();
-    if (stream_ == NULL) {
-      return NULL;
+    if (stream_ == nullptr) {
+      return nullptr;
     }
     stream_->set_visitor(this);
     reinterpret_cast<QuicSpdyClientStream*>(stream_)->set_priority(priority_);
     // Set FEC policy on stream.
     ReliableQuicStreamPeer::SetFecPolicy(stream_, fec_policy_);
   }
 
   return stream_;
 }
 
 QuicErrorCode QuicTestClient::connection_error() {
   return client()->session()->error();
 }
 
 MockableQuicClient* QuicTestClient::client() { return client_.get(); }
 
 const string& QuicTestClient::cert_common_name() const {
   return reinterpret_cast<RecordingProofVerifier*>(proof_verifier_)
       ->common_name();
 }
 
 QuicTagValueMap QuicTestClient::GetServerConfig() const {
   QuicCryptoClientConfig* config =
       QuicClientPeer::GetCryptoConfig(client_.get());
   QuicCryptoClientConfig::CachedState* state =
       config->LookupOrCreate(client_->server_id());
   const CryptoHandshakeMessage* handshake_msg = state->GetServerConfig();
-  if (handshake_msg != NULL) {
+  if (handshake_msg != nullptr) {
     return handshake_msg->tag_value_map();
   } else {
     return QuicTagValueMap();
   }
 }
 
 bool QuicTestClient::connected() const {
   return client_->connected();
 }
 
@@ skipping 15 matching lines @@
   client_->Disconnect();
   connect_attempted_ = false;
 }
 
 IPEndPoint QuicTestClient::LocalSocketAddress() const {
   return client_->client_address();
 }
 
 void QuicTestClient::ClearPerRequestState() {
   stream_error_ = QUIC_STREAM_NO_ERROR;
-  stream_ = NULL;
+  stream_ = nullptr;
   response_ = "";
   response_complete_ = false;
   response_headers_complete_ = false;
   headers_.Clear();
   bytes_read_ = 0;
   bytes_written_ = 0;
   response_header_size_ = 0;
   response_body_size_ = 0;
 }
 
 void QuicTestClient::WaitForResponseForMs(int timeout_ms) {
   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
   int64 old_timeout_us = epoll_server()->timeout_in_us();
   if (timeout_us > 0) {
     epoll_server()->set_timeout_in_us(timeout_us);
   }
   const QuicClock* clock =
       QuicConnectionPeer::GetHelper(client()->session()->connection())->
           GetClock();
   QuicTime end_waiting_time = clock->Now().Add(
       QuicTime::Delta::FromMicroseconds(timeout_us));
-  while (stream_ != NULL &&
+  while (stream_ != nullptr &&
          !client_->session()->IsClosedStream(stream_->id()) &&
          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
     client_->WaitForEvents();
   }
   if (timeout_us > 0) {
     epoll_server()->set_timeout_in_us(old_timeout_us);
   }
 }
 
 void QuicTestClient::WaitForInitialResponseForMs(int timeout_ms) {
   int64 timeout_us = timeout_ms * base::Time::kMicrosecondsPerMillisecond;
   int64 old_timeout_us = epoll_server()->timeout_in_us();
   if (timeout_us > 0) {
     epoll_server()->set_timeout_in_us(timeout_us);
   }
   const QuicClock* clock =
       QuicConnectionPeer::GetHelper(client()->session()->connection())->
           GetClock();
   QuicTime end_waiting_time = clock->Now().Add(
       QuicTime::Delta::FromMicroseconds(timeout_us));
-  while (stream_ != NULL &&
+  while (stream_ != nullptr &&
          !client_->session()->IsClosedStream(stream_->id()) &&
          stream_->stream_bytes_read() == 0 &&
          (timeout_us < 0 || clock->Now() < end_waiting_time)) {
     client_->WaitForEvents();
   }
   if (timeout_us > 0) {
     epoll_server()->set_timeout_in_us(old_timeout_us);
   }
 }
 
 ssize_t QuicTestClient::Send(const void *buffer, size_t size) {
   return SendData(string(static_cast<const char*>(buffer), size), false);
 }
 
 bool QuicTestClient::response_headers_complete() const {
-  if (stream_ != NULL) {
+  if (stream_ != nullptr) {
     return stream_->headers_decompressed();
   } else {
     return response_headers_complete_;
   }
 }
 
 const BalsaHeaders* QuicTestClient::response_headers() const {
-  if (stream_ != NULL) {
+  if (stream_ != nullptr) {
     return &stream_->headers();
   } else {
     return &headers_;
   }
 }
 
 int64 QuicTestClient::response_size() const {
   return bytes_read_;
 }
 
@@ skipping 15 matching lines @@
   }
   response_complete_ = true;
   response_headers_complete_ = stream_->headers_decompressed();
   headers_.CopyFrom(stream_->headers());
   stream_error_ = stream_->stream_error();
   bytes_read_ = stream_->stream_bytes_read() + stream_->header_bytes_read();
   bytes_written_ =
       stream_->stream_bytes_written() + stream_->header_bytes_written();
   response_header_size_ = headers_.GetSizeForWriteBuffer();
   response_body_size_ = stream_->data().size();
-  stream_ = NULL;
+  stream_ = nullptr;
 }
 
 void QuicTestClient::UseWriter(QuicPacketWriterWrapper* writer) {
   client_->UseWriter(writer);
 }
 
 void QuicTestClient::UseConnectionId(QuicConnectionId connection_id) {
   DCHECK(!connected());
   client_->UseConnectionId(connection_id);
 }
@@ skipping 42 matching lines @@
   // Set policy for headers and crypto streams.
   ReliableQuicStreamPeer::SetFecPolicy(
       QuicSessionPeer::GetHeadersStream(client()->session()), fec_policy);
   ReliableQuicStreamPeer::SetFecPolicy(client()->session()->GetCryptoStream(),
                                        fec_policy);
 }
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net