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

net/quic/reliable_quic_stream.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/reliable_quic_stream.h"
 
 #include "base/logging.h"
 #include "net/quic/iovector.h"
 #include "net/quic/quic_flow_controller.h"
 #include "net/quic/quic_session.h"
@@ skipping 256 matching lines @@
     LOG(DFATAL) << "data.empty() && !fin";
     return;
   }
 
   if (fin_buffered_) {
     LOG(DFATAL) << "Fin already buffered";
     return;
   }
 
   scoped_refptr<ProxyAckNotifierDelegate> proxy_delegate;
-  if (ack_notifier_delegate != NULL) {
+  if (ack_notifier_delegate != nullptr) {
     proxy_delegate = new ProxyAckNotifierDelegate(ack_notifier_delegate);
   }
 
   QuicConsumedData consumed_data(0, false);
   fin_buffered_ = fin;
 
   if (queued_data_.empty()) {
     struct iovec iov(MakeIovec(data));
     consumed_data = WritevData(&iov, 1, fin, proxy_delegate.get());
     DCHECK_LE(consumed_data.bytes_consumed, data.length());
   }
 
   bool write_completed;
   // If there's unconsumed data or an unconsumed fin, queue it.
   if (consumed_data.bytes_consumed < data.length() ||
       (fin && !consumed_data.fin_consumed)) {
     StringPiece remainder(data.substr(consumed_data.bytes_consumed));
     queued_data_.push_back(PendingData(remainder.as_string(), proxy_delegate));
     write_completed = false;
   } else {
     write_completed = true;
   }
 
-  if ((proxy_delegate.get() != NULL) &&
+  if ((proxy_delegate.get() != nullptr) &&
       (consumed_data.bytes_consumed > 0 || consumed_data.fin_consumed)) {
     proxy_delegate->WroteData(write_completed);
   }
 }
 
 void ReliableQuicStream::OnCanWrite() {
   bool fin = false;
   while (!queued_data_.empty()) {
     PendingData* pending_data = &queued_data_.front();
     ProxyAckNotifierDelegate* delegate = pending_data->delegate.get();
     if (queued_data_.size() == 1 && fin_buffered_) {
       fin = true;
     }
     struct iovec iov(MakeIovec(pending_data->data));
     QuicConsumedData consumed_data = WritevData(&iov, 1, fin, delegate);
     if (consumed_data.bytes_consumed == pending_data->data.size() &&
         fin == consumed_data.fin_consumed) {
       queued_data_.pop_front();
-      if (delegate != NULL) {
+      if (delegate != nullptr) {
         delegate->WroteData(true);
       }
     } else {
       if (consumed_data.bytes_consumed > 0) {
         pending_data->data.erase(0, consumed_data.bytes_consumed);
-        if (delegate != NULL) {
+        if (delegate != nullptr) {
           delegate->WroteData(false);
         }
       }
       break;
     }
   }
 }
 
 void ReliableQuicStream::MaybeSendBlocked() {
   flow_controller_.MaybeSendBlocked();
@@ skipping 198 matching lines @@
 
 bool ReliableQuicStream::IsFlowControlBlocked() {
   if (flow_controller_.IsBlocked()) {
     return true;
   }
   return stream_contributes_to_connection_flow_control_ &&
       connection_flow_controller_->IsBlocked();
 }
 
 }  // namespace net