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

net/tools/quic/test_tools/packet_dropping_test_writer.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/tools/quic/test_tools/packet_dropping_test_writer.h"
 
 #include <limits>
 
 #include "base/rand_util.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
@@ skipping 28 matching lines @@
 
   virtual QuicTime OnAlarm() OVERRIDE {
     return writer_->ReleaseOldPackets();
   }
 
  private:
   PacketDroppingTestWriter* writer_;
 };
 
 PacketDroppingTestWriter::PacketDroppingTestWriter()
-    : clock_(NULL),
+    : clock_(nullptr),
       cur_buffer_size_(0),
       config_mutex_(),
       fake_packet_loss_percentage_(0),
       fake_blocked_socket_percentage_(0),
       fake_packet_reorder_percentage_(0),
       fake_packet_delay_(QuicTime::Delta::Zero()),
       fake_bandwidth_(QuicBandwidth::Zero()),
       buffer_size_(0) {
   uint32 seed = base::RandInt(0, std::numeric_limits<int32>::max());
   VLOG(1) << "Seeding packet loss with " << seed;
@@ skipping 23 matching lines @@
   base::AutoLock locked(config_mutex_);
   if (fake_packet_loss_percentage_ > 0 &&
       simple_random_.RandUint64() % 100 <
           static_cast<uint64>(fake_packet_loss_percentage_)) {
     DVLOG(1) << "Dropping packet.";
     return WriteResult(WRITE_STATUS_OK, buf_len);
   }
   if (fake_blocked_socket_percentage_ > 0 &&
       simple_random_.RandUint64() % 100 <
           static_cast<uint64>(fake_blocked_socket_percentage_)) {
-    CHECK(on_can_write_.get() != NULL);
+    CHECK(on_can_write_.get() != nullptr);
     DVLOG(1) << "Blocking socket.";
     if (!write_unblocked_alarm_->IsSet()) {
       // Set the alarm to fire immediately.
       write_unblocked_alarm_->Set(clock_->ApproximateNow());
     }
     return WriteResult(WRITE_STATUS_BLOCKED, EAGAIN);
   }
 
   if (!fake_packet_delay_.IsZero() || !fake_bandwidth_.IsZero()) {
     if (buffer_size_ > 0 && buf_len + cur_buffer_size_ > buffer_size_) {
@@ skipping 23 matching lines @@
     }
 
     return WriteResult(WRITE_STATUS_OK, buf_len);
   }
 
   return QuicPacketWriterWrapper::WritePacket(
       buffer, buf_len, self_address, peer_address);
 }
 
 bool PacketDroppingTestWriter::IsWriteBlocked() const {
-  if (write_unblocked_alarm_.get() != NULL && write_unblocked_alarm_->IsSet()) {
+  if (write_unblocked_alarm_.get() != nullptr &&
+      write_unblocked_alarm_->IsSet()) {
     return true;
   }
   return QuicPacketWriterWrapper::IsWriteBlocked();
 }
 
 void PacketDroppingTestWriter::SetWritable() {
-  if (write_unblocked_alarm_.get() != NULL && write_unblocked_alarm_->IsSet()) {
+  if (write_unblocked_alarm_.get() != nullptr &&
+      write_unblocked_alarm_->IsSet()) {
     write_unblocked_alarm_->Cancel();
   }
   QuicPacketWriterWrapper::SetWritable();
 }
 
 QuicTime PacketDroppingTestWriter::ReleaseNextPacket() {
   if (delayed_packets_.empty()) {
     return QuicTime::Zero();
   }
   base::AutoLock locked(config_mutex_);
@@ skipping 49 matching lines @@
     : buffer(buffer, buf_len),
       self_address(self_address),
       peer_address(peer_address),
       send_time(send_time) {}
 
 PacketDroppingTestWriter::DelayedWrite::~DelayedWrite() {}
 
 }  // namespace test
 }  // namespace tools
 }  // namespace net