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

net/quic/quic_headers_stream_test.cc

 // Copyright 2013 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_headers_stream.h"
 
 #include "net/quic/quic_utils.h"
 #include "net/quic/spdy_utils.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
@@ skipping 72 matching lines @@
       : connection_(new StrictMock<MockConnection>(is_server(), GetVersions())),
         session_(connection_),
         headers_stream_(QuicSessionPeer::GetHeadersStream(&session_)),
         body_("hello world"),
         framer_(SPDY3) {
     headers_[":version"]  = "HTTP/1.1";
     headers_[":status"] = "200 Ok";
     headers_["content-length"] = "11";
     framer_.set_visitor(&visitor_);
     EXPECT_EQ(QuicVersionMax(), session_.connection()->version());
-    EXPECT_TRUE(headers_stream_ != NULL);
+    EXPECT_TRUE(headers_stream_ != nullptr);
   }
 
   QuicConsumedData SaveIov(const IOVector& data) {
     const iovec* iov = data.iovec();
     int count = data.Capacity();
     for (int i = 0 ; i < count; ++i) {
       saved_data_.append(static_cast<char*>(iov[i].iov_base), iov[i].iov_len);
     }
     return QuicConsumedData(saved_data_.length(), false);
   }
@@ skipping 16 matching lines @@
   void WriteHeadersAndExpectSynReply(QuicStreamId stream_id,
                                      bool fin) {
     WriteHeadersAndCheckData(stream_id, fin, 0, SYN_REPLY);
   }
 
   void WriteHeadersAndCheckData(QuicStreamId stream_id,
                                 bool fin,
                                 QuicPriority priority,
                                 SpdyFrameType type) {
     // Write the headers and capture the outgoing data
-    EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, false, _, NULL))
+    EXPECT_CALL(session_, WritevData(kHeadersStreamId, _, _, false, _, nullptr))
         .WillOnce(WithArgs<1>(Invoke(this, &QuicHeadersStreamTest::SaveIov)));
-    headers_stream_->WriteHeaders(stream_id, headers_, fin, NULL);
+    headers_stream_->WriteHeaders(stream_id, headers_, fin, nullptr);
 
     // Parse the outgoing data and check that it matches was was written.
     if (type == SYN_STREAM) {
       EXPECT_CALL(visitor_, OnSynStream(stream_id, kNoAssociatedStream, 0,
                                         // priority,
                                         fin, kNotUnidirectional));
     } else {
       EXPECT_CALL(visitor_, OnSynReply(stream_id, fin));
     }
     EXPECT_CALL(visitor_, OnControlFrameHeaderData(stream_id, _, _))
         .WillRepeatedly(WithArgs<1, 2>(
             Invoke(this, &QuicHeadersStreamTest::SaveHeaderData)));
     if (fin) {
-      EXPECT_CALL(visitor_, OnStreamFrameData(stream_id, NULL, 0, true));
+      EXPECT_CALL(visitor_, OnStreamFrameData(stream_id, nullptr, 0, true));
     }
     framer_.ProcessInput(saved_data_.data(), saved_data_.length());
     EXPECT_FALSE(framer_.HasError()) << framer_.error_code();
 
     CheckHeaders();
     saved_data_.clear();
   }
 
   void CheckHeaders() {
     SpdyHeaderBlock headers;
@@ skipping 174 matching lines @@
   } else {
     EXPECT_TRUE(headers_stream_->flow_controller()->IsEnabled());
   }
   EXPECT_FALSE(ReliableQuicStreamPeer::StreamContributesToConnectionFlowControl(
       headers_stream_));
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net