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

net/quic/quic_http_stream_test.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_http_stream.h"
 
 #include <vector>
 
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
@@ skipping 175 matching lines @@
 
   // Configures the test fixture to use the list of expected writes.
   void Initialize() {
     mock_writes_.reset(new MockWrite[writes_.size()]);
     for (size_t i = 0; i < writes_.size(); i++) {
       mock_writes_[i] = MockWrite(writes_[i].mode,
                                   writes_[i].packet->data(),
                                   writes_[i].packet->length());
     };
 
-    socket_data_.reset(new StaticSocketDataProvider(NULL, 0, mock_writes_.get(),
-                                                    writes_.size()));
+    socket_data_.reset(new StaticSocketDataProvider(
+        nullptr, 0, mock_writes_.get(), writes_.size()));
 
     MockUDPClientSocket* socket = new MockUDPClientSocket(socket_data_.get(),
                                                           net_log_.net_log());
     socket->Connect(peer_addr_);
     runner_ = new TestTaskRunner(&clock_);
     send_algorithm_ = new MockSendAlgorithm();
     receive_algorithm_ = new TestReceiveAlgorithm();
     EXPECT_CALL(*receive_algorithm_, RecordIncomingPacket(_, _, _)).
         Times(AnyNumber());
     EXPECT_CALL(*send_algorithm_,
@@ skipping 13 matching lines @@
     connection_ = new TestQuicConnection(SupportedVersions(GetParam()),
                                          connection_id_, peer_addr_,
                                          helper_.get(), writer_factory);
     connection_->set_visitor(&visitor_);
     connection_->SetSendAlgorithm(send_algorithm_);
     connection_->SetReceiveAlgorithm(receive_algorithm_);
     crypto_config_.SetDefaults();
     session_.reset(
         new QuicClientSession(connection_,
                               scoped_ptr<DatagramClientSocket>(socket),
-                              NULL,
+                              nullptr,
                               &transport_security_state_,
-                              make_scoped_ptr((QuicServerInfo*)NULL),
+                              make_scoped_ptr((QuicServerInfo*)nullptr),
                               DefaultQuicConfig(),
                               base::MessageLoop::current()->
                                   message_loop_proxy().get(),
-                              NULL));
+                              nullptr));
     session_->InitializeSession(QuicServerId(kServerHostname, kServerPort,
                                              false, PRIVACY_MODE_DISABLED),
                                 &crypto_config_,
                                 &crypto_client_stream_factory_);
     session_->GetCryptoStream()->CryptoConnect();
     EXPECT_TRUE(session_->IsCryptoHandshakeConfirmed());
     stream_.reset(use_closing_stream_ ?
                   new AutoClosingStream(session_->GetWeakPtr()) :
                   new QuicHttpStream(session_->GetWeakPtr()));
   }
@@ skipping 89 matching lines @@
   MockCryptoClientStreamFactory crypto_client_stream_factory_;
   scoped_ptr<StaticSocketDataProvider> socket_data_;
   std::vector<PacketToWrite> writes_;
 };
 
 INSTANTIATE_TEST_CASE_P(Version, QuicHttpStreamTest,
                         ::testing::ValuesIn(QuicSupportedVersions()));
 
 TEST_P(QuicHttpStreamTest, RenewStreamForAuth) {
   Initialize();
-  EXPECT_EQ(NULL, stream_->RenewStreamForAuth());
+  EXPECT_EQ(nullptr, stream_->RenewStreamForAuth());
 }
 
 TEST_P(QuicHttpStreamTest, CanFindEndOfResponse) {
   Initialize();
   EXPECT_TRUE(stream_->CanFindEndOfResponse());
 }
 
 TEST_P(QuicHttpStreamTest, IsConnectionReusable) {
   Initialize();
   EXPECT_FALSE(stream_->IsConnectionReusable());
@@ skipping 234 matching lines @@
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
-  upload_data_stream.AppendChunk(NULL, 0, true);
+  upload_data_stream.AppendChunk(nullptr, 0, true);
 
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
   ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
 
   // Since the headers have already arrived, this should return immediately.
   ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
   ASSERT_TRUE(response_.headers.get());
@@ skipping 26 matching lines @@
   request_.method = "POST";
   request_.url = GURL("http://www.google.com/");
   request_.upload_data_stream = &upload_data_stream;
   ASSERT_EQ(OK, request_.upload_data_stream->Init(CompletionCallback()));
 
   ASSERT_EQ(OK, stream_->InitializeStream(&request_, DEFAULT_PRIORITY,
                                           net_log_, callback_.callback()));
   ASSERT_EQ(ERR_IO_PENDING, stream_->SendRequest(headers_, &response_,
                                                  callback_.callback()));
 
-  upload_data_stream.AppendChunk(NULL, 0, true);
+  upload_data_stream.AppendChunk(nullptr, 0, true);
 
   ProcessPacket(ConstructAckPacket(1, 0, 0));
 
   // Send the response headers (but not the body).
   SetResponse("200 OK", std::string());
   ProcessPacket(ConstructResponseHeadersPacket(2, !kFin));
 
   // Since the headers have already arrived, this should return immediately.
   ASSERT_EQ(OK, stream_->ReadResponseHeaders(callback_.callback()));
   ASSERT_TRUE(response_.headers.get());
@@ skipping 99 matching lines @@
 
   // Check that priority is highest.
   QuicReliableClientStream* reliable_stream =
       QuicHttpStreamPeer::GetQuicReliableClientStream(stream_.get());
   DCHECK(reliable_stream);
   QuicReliableClientStream::Delegate* delegate = reliable_stream->GetDelegate();
   DCHECK(delegate);
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
 
-  // Set Delegate to NULL and make sure EffectivePriority returns highest
+  // Set Delegate to nullptr and make sure EffectivePriority returns highest
   // priority.
-  reliable_stream->SetDelegate(NULL);
+  reliable_stream->SetDelegate(nullptr);
   DCHECK_EQ(QuicWriteBlockedList::kHighestPriority,
             reliable_stream->EffectivePriority());
   reliable_stream->SetDelegate(delegate);
 }
 
 }  // namespace test
 }  // namespace net