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

net/quic/crypto/crypto_framer.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/crypto/crypto_framer.h"
 
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/quic_data_reader.h"
 #include "net/quic/quic_data_writer.h"
 
@@ skipping 27 matching lines @@
   CryptoHandshakeMessage* release() { return out_.release(); }
 
  private:
   scoped_ptr<CryptoHandshakeMessage> out_;
   bool error_;
 };
 
 }  // namespace
 
 CryptoFramer::CryptoFramer()
-    : visitor_(NULL),
+    : visitor_(nullptr),
       num_entries_(0),
       values_len_(0) {
   Clear();
 }
 
 CryptoFramer::~CryptoFramer() {}
 
 // static
 CryptoHandshakeMessage* CryptoFramer::ParseMessage(StringPiece in) {
   OneShotVisitor visitor;
   CryptoFramer framer;
 
   framer.set_visitor(&visitor);
   if (!framer.ProcessInput(in) || visitor.error() ||
       framer.InputBytesRemaining()) {
-    return NULL;
+    return nullptr;
   }
 
   return visitor.release();
 }
 
 bool CryptoFramer::ProcessInput(StringPiece input) {
   DCHECK_EQ(QUIC_NO_ERROR, error_);
   if (error_ != QUIC_NO_ERROR) {
     return false;
   }
@@ skipping 22 matching lines @@
 
     size_t delta = message.minimum_size() - len;
     const size_t overhead = kQuicTagSize + kCryptoEndOffsetSize;
     if (delta > overhead) {
       pad_length = delta - overhead;
     }
     len += overhead + pad_length;
   }
 
   if (num_entries > kMaxEntries) {
-    return NULL;
+    return nullptr;
   }
 
 
   QuicDataWriter writer(len);
   if (!writer.WriteUInt32(message.tag())) {
     DCHECK(false) << "Failed to write message tag.";
-    return NULL;
+    return nullptr;
   }
   if (!writer.WriteUInt16(num_entries)) {
     DCHECK(false) << "Failed to write size.";
-    return NULL;
+    return nullptr;
   }
   if (!writer.WriteUInt16(0)) {
     DCHECK(false) << "Failed to write padding.";
-    return NULL;
+    return nullptr;
   }
 
   uint32 end_offset = 0;
   // Tags and offsets
   for (QuicTagValueMap::const_iterator it = message.tag_value_map().begin();
        it != message.tag_value_map().end(); ++it) {
     if (it->first == kPAD && need_pad_tag) {
       // Existing PAD tags are only checked when padding needs to be added
       // because parts of the code may need to reserialize received messages
       // and those messages may, legitimately include padding.
       DCHECK(false) << "Message needed padding but already contained a PAD tag";
-      return NULL;
+      return nullptr;
     }
 
     if (it->first > kPAD && need_pad_tag) {
       need_pad_tag = false;
       if (!WritePadTag(&writer, pad_length, &end_offset)) {
-        return NULL;
+        return nullptr;
       }
     }
 
     if (!writer.WriteUInt32(it->first)) {
       DCHECK(false) << "Failed to write tag.";
-      return NULL;
+      return nullptr;
     }
     end_offset += it->second.length();
     if (!writer.WriteUInt32(end_offset)) {
       DCHECK(false) << "Failed to write end offset.";
-      return NULL;
+      return nullptr;
     }
   }
 
   if (need_pad_tag) {
     if (!WritePadTag(&writer, pad_length, &end_offset)) {
-      return NULL;
+      return nullptr;
     }
   }
 
   // Values
   for (QuicTagValueMap::const_iterator it = message.tag_value_map().begin();
        it != message.tag_value_map().end(); ++it) {
     if (it->first > kPAD && need_pad_value) {
       need_pad_value = false;
       if (!writer.WriteRepeatedByte('-', pad_length)) {
         DCHECK(false) << "Failed to write padding.";
-        return NULL;
+        return nullptr;
       }
     }
 
     if (!writer.WriteBytes(it->second.data(), it->second.length())) {
       DCHECK(false) << "Failed to write value.";
-      return NULL;
+      return nullptr;
     }
   }
 
   if (need_pad_value) {
     if (!writer.WriteRepeatedByte('-', pad_length)) {
       DCHECK(false) << "Failed to write padding.";
-      return NULL;
+      return nullptr;
     }
   }
 
   return new QuicData(writer.take(), len, true);
 }
 
 void CryptoFramer::Clear() {
   message_.Clear();
   tags_and_lengths_.clear();
   error_ = QUIC_NO_ERROR;
@@ skipping 89 matching lines @@
   }
   *end_offset += pad_length;
   if (!writer->WriteUInt32(*end_offset)) {
     DCHECK(false) << "Failed to write end offset.";
     return false;
   }
   return true;
 }
 
 }  // namespace net