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

net/quic/quic_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/quic_framer.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/stl_util.h"
 #include "net/quic/crypto/crypto_framer.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
@@ skipping 128 matching lines @@
   return true;
 }
 
 bool QuicFramerVisitorInterface::OnBlockedFrame(const QuicBlockedFrame& frame) {
   return true;
 }
 
 QuicFramer::QuicFramer(const QuicVersionVector& supported_versions,
                        QuicTime creation_time,
                        bool is_server)
-    : visitor_(NULL),
-      fec_builder_(NULL),
-      entropy_calculator_(NULL),
+    : visitor_(nullptr),
+      fec_builder_(nullptr),
+      entropy_calculator_(nullptr),
       error_(QUIC_NO_ERROR),
       last_sequence_number_(0),
       last_serialized_connection_id_(0),
       supported_versions_(supported_versions),
       decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_level_(ENCRYPTION_NONE),
       alternative_decrypter_latch_(false),
       is_server_(is_server),
       validate_flags_(true),
       creation_time_(creation_time),
@@ skipping 153 matching lines @@
 QuicPacketEntropyHash QuicFramer::GetPacketEntropyHash(
     const QuicPacketHeader& header) const {
   return header.entropy_flag << (header.packet_sequence_number % 8);
 }
 
 SerializedPacket QuicFramer::BuildDataPacket(
     const QuicPacketHeader& header,
     const QuicFrames& frames,
     size_t packet_size) {
   QuicDataWriter writer(packet_size);
-  const SerializedPacket kNoPacket(
-      0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
+  const SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0,
+                                   nullptr);
   if (!AppendPacketHeader(header, &writer)) {
     LOG(DFATAL) << "AppendPacketHeader failed";
     return kNoPacket;
   }
 
   for (size_t i = 0; i < frames.size(); ++i) {
     const QuicFrame& frame = frames[i];
 
     // Determine if we should write stream frame length in header.
     const bool no_stream_frame_length =
@@ skipping 87 matching lines @@
       header.public_header.version_flag,
       header.public_header.sequence_number_length);
 
   if (fec_builder_) {
     fec_builder_->OnBuiltFecProtectedPayload(header,
                                              packet->FecProtectedData());
   }
 
   return SerializedPacket(header.packet_sequence_number,
                           header.public_header.sequence_number_length, packet,
-                          GetPacketEntropyHash(header), NULL);
+                          GetPacketEntropyHash(header), nullptr);
 }
 
 SerializedPacket QuicFramer::BuildFecPacket(const QuicPacketHeader& header,
                                             const QuicFecData& fec) {
   DCHECK_EQ(IN_FEC_GROUP, header.is_in_fec_group);
   DCHECK_NE(0u, header.fec_group);
   size_t len = GetPacketHeaderSize(header);
   len += fec.redundancy.length();
 
   QuicDataWriter writer(len);
-  const SerializedPacket kNoPacket(
-      0, PACKET_1BYTE_SEQUENCE_NUMBER, NULL, 0, NULL);
+  const SerializedPacket kNoPacket(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0,
+                                   nullptr);
   if (!AppendPacketHeader(header, &writer)) {
     LOG(DFATAL) << "AppendPacketHeader failed";
     return kNoPacket;
   }
 
   if (!writer.WriteBytes(fec.redundancy.data(), fec.redundancy.length())) {
     LOG(DFATAL) << "Failed to add FEC";
     return kNoPacket;
   }
 
   return SerializedPacket(
       header.packet_sequence_number,
       header.public_header.sequence_number_length,
       QuicPacket::NewFecPacket(writer.take(), len, true,
                                header.public_header.connection_id_length,
                                header.public_header.version_flag,
                                header.public_header.sequence_number_length),
-      GetPacketEntropyHash(header), NULL);
+      GetPacketEntropyHash(header), nullptr);
 }
 
 // static
 QuicEncryptedPacket* QuicFramer::BuildPublicResetPacket(
     const QuicPublicResetPacket& packet) {
   DCHECK(packet.public_header.reset_flag);
 
   CryptoHandshakeMessage reset;
   reset.set_tag(kPRST);
   reset.SetValue(kRNON, packet.nonce_proof);
   reset.SetValue(kRSEQ, packet.rejected_sequence_number);
   if (!packet.client_address.address().empty()) {
     // packet.client_address is non-empty.
     QuicSocketAddressCoder address_coder(packet.client_address);
     string serialized_address = address_coder.Encode();
     if (serialized_address.empty()) {
-      return NULL;
+      return nullptr;
     }
     reset.SetStringPiece(kCADR, serialized_address);
   }
   const QuicData& reset_serialized = reset.GetSerialized();
 
   size_t len =
       kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID + reset_serialized.length();
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_RST |
                                    PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID);
   if (!writer.WriteUInt8(flags)) {
-    return NULL;
+    return nullptr;
   }
 
   if (!writer.WriteUInt64(packet.public_header.connection_id)) {
-    return NULL;
+    return nullptr;
   }
 
   if (!writer.WriteBytes(reset_serialized.data(), reset_serialized.length())) {
-    return NULL;
+    return nullptr;
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 QuicEncryptedPacket* QuicFramer::BuildVersionNegotiationPacket(
     const QuicPacketPublicHeader& header,
     const QuicVersionVector& supported_versions) {
   DCHECK(header.version_flag);
   size_t len = GetVersionNegotiationPacketSize(supported_versions.size());
   QuicDataWriter writer(len);
 
   uint8 flags = static_cast<uint8>(PACKET_PUBLIC_FLAGS_VERSION |
                                    PACKET_PUBLIC_FLAGS_8BYTE_CONNECTION_ID);
   if (!writer.WriteUInt8(flags)) {
-    return NULL;
+    return nullptr;
   }
 
   if (!writer.WriteUInt64(header.connection_id)) {
-    return NULL;
+    return nullptr;
   }
 
   for (size_t i = 0; i < supported_versions.size(); ++i) {
     if (!writer.WriteUInt32(QuicVersionToQuicTag(supported_versions[i]))) {
-      return NULL;
+      return nullptr;
     }
   }
 
   return new QuicEncryptedPacket(writer.take(), len, true);
 }
 
 bool QuicFramer::ProcessPacket(const QuicEncryptedPacket& packet) {
   DCHECK(!reader_.get());
   reader_.reset(new QuicDataReader(packet.data(), packet.length()));
 
   visitor_->OnPacket();
 
   // First parse the public header.
   QuicPacketPublicHeader public_header;
   if (!ProcessPublicHeader(&public_header)) {
     DLOG(WARNING) << "Unable to process public header.";
     DCHECK_NE("", detailed_error_);
     return RaiseError(QUIC_INVALID_PACKET_HEADER);
   }
 
   if (!visitor_->OnUnauthenticatedPublicHeader(public_header)) {
     // The visitor suppresses further processing of the packet.
-    reader_.reset(NULL);
+    reader_.reset(nullptr);
     return true;
   }
 
   if (is_server_ && public_header.version_flag &&
       public_header.versions[0] != quic_version_) {
     if (!visitor_->OnProtocolVersionMismatch(public_header.versions[0])) {
-      reader_.reset(NULL);
+      reader_.reset(nullptr);
       return true;
     }
   }
 
   bool rv;
   if (!is_server_ && public_header.version_flag) {
     rv = ProcessVersionNegotiationPacket(&public_header);
   } else if (public_header.reset_flag) {
     rv = ProcessPublicResetPacket(public_header);
   } else {
     rv = ProcessDataPacket(public_header, packet);
   }
 
-  reader_.reset(NULL);
+  reader_.reset(nullptr);
   return rv;
 }
 
 bool QuicFramer::ProcessVersionNegotiationPacket(
     QuicPacketPublicHeader* public_header) {
   DCHECK(!is_server_);
   // Try reading at least once to raise error if the packet is invalid.
   do {
     QuicTag version;
     if (!reader_->ReadBytes(&version, kQuicVersionSize)) {
@@ skipping 106 matching lines @@
   }
 
   reader_.reset(new QuicDataReader(payload.data(), payload.length()));
   if (!ProcessFrameData(*header)) {
     DCHECK_NE(QUIC_NO_ERROR, error_);  // ProcessFrameData sets the error.
     DLOG(WARNING) << "Unable to process frame data.";
     return false;
   }
 
   visitor_->OnPacketComplete();
-  reader_.reset(NULL);
+  reader_.reset(nullptr);
   return true;
 }
 
 bool QuicFramer::AppendPacketHeader(const QuicPacketHeader& header,
                                     QuicDataWriter* writer) {
   DVLOG(1) << "Appending header: " << header;
   DCHECK(header.fec_group > 0 || header.is_in_fec_group == NOT_IN_FEC_GROUP);
   uint8 public_flags = 0;
   if (header.public_header.reset_flag) {
     public_flags |= PACKET_PUBLIC_FLAGS_RST;
@@ skipping 923 matching lines @@
     bool includes_version,
     QuicSequenceNumberLength sequence_number_length) {
   return StringPiece(
       encrypted.data() + kStartOfHashData, GetStartOfEncryptedData(
           connection_id_length, includes_version, sequence_number_length)
       - kStartOfHashData);
 }
 
 void QuicFramer::SetDecrypter(QuicDecrypter* decrypter,
                               EncryptionLevel level) {
-  DCHECK(alternative_decrypter_.get() == NULL);
+  DCHECK(alternative_decrypter_.get() == nullptr);
   DCHECK_GE(level, decrypter_level_);
   decrypter_.reset(decrypter);
   decrypter_level_ = level;
 }
 
 void QuicFramer::SetAlternativeDecrypter(QuicDecrypter* decrypter,
                                          EncryptionLevel level,
                                          bool latch_once_used) {
   alternative_decrypter_.reset(decrypter);
   alternative_decrypter_level_ = level;
@@ skipping 11 matching lines @@
 void QuicFramer::SetEncrypter(EncryptionLevel level,
                               QuicEncrypter* encrypter) {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
   encrypter_[level].reset(encrypter);
 }
 
 const QuicEncrypter* QuicFramer::encrypter(EncryptionLevel level) const {
   DCHECK_GE(level, 0);
   DCHECK_LT(level, NUM_ENCRYPTION_LEVELS);
-  DCHECK(encrypter_[level].get() != NULL);
+  DCHECK(encrypter_[level].get() != nullptr);
   return encrypter_[level].get();
 }
 
 QuicEncryptedPacket* QuicFramer::EncryptPacket(
     EncryptionLevel level,
     QuicPacketSequenceNumber packet_sequence_number,
     const QuicPacket& packet) {
-  DCHECK(encrypter_[level].get() != NULL);
+  DCHECK(encrypter_[level].get() != nullptr);
 
   scoped_ptr<QuicData> out(encrypter_[level]->EncryptPacket(
       packet_sequence_number, packet.AssociatedData(), packet.Plaintext()));
-  if (out.get() == NULL) {
+  if (out.get() == nullptr) {
     RaiseError(QUIC_ENCRYPTION_FAILURE);
-    return NULL;
+    return nullptr;
   }
   StringPiece header_data = packet.BeforePlaintext();
   size_t len =  header_data.length() + out->length();
   char* buffer = new char[len];
   // TODO(rch): eliminate this buffer copy by passing in a buffer to Encrypt().
   memcpy(buffer, header_data.data(), header_data.length());
   memcpy(buffer + header_data.length(), out->data(), out->length());
   return new QuicEncryptedPacket(buffer, len, true);
 }
 
 size_t QuicFramer::GetMaxPlaintextSize(size_t ciphertext_size) {
   // In order to keep the code simple, we don't have the current encryption
   // level to hand. Both the NullEncrypter and AES-GCM have a tag length of 12.
   size_t min_plaintext_size = ciphertext_size;
 
   for (int i = ENCRYPTION_NONE; i < NUM_ENCRYPTION_LEVELS; i++) {
-    if (encrypter_[i].get() != NULL) {
+    if (encrypter_[i].get() != nullptr) {
       size_t size = encrypter_[i]->GetMaxPlaintextSize(ciphertext_size);
       if (size < min_plaintext_size) {
         min_plaintext_size = size;
       }
     }
   }
 
   return min_plaintext_size;
 }
 
 bool QuicFramer::DecryptPayload(const QuicPacketHeader& header,
                                 const QuicEncryptedPacket& packet) {
   StringPiece encrypted;
   if (!reader_->ReadStringPiece(&encrypted, reader_->BytesRemaining())) {
     return false;
   }
-  DCHECK(decrypter_.get() != NULL);
+  DCHECK(decrypter_.get() != nullptr);
   decrypted_.reset(decrypter_->DecryptPacket(
       header.packet_sequence_number,
       GetAssociatedDataFromEncryptedPacket(
           packet,
           header.public_header.connection_id_length,
           header.public_header.version_flag,
           header.public_header.sequence_number_length),
       encrypted));
-  if  (decrypted_.get() != NULL) {
+  if (decrypted_.get() != nullptr) {
     visitor_->OnDecryptedPacket(decrypter_level_);
-  } else if  (alternative_decrypter_.get() != NULL) {
+  } else if (alternative_decrypter_.get() != nullptr) {
     decrypted_.reset(alternative_decrypter_->DecryptPacket(
         header.packet_sequence_number,
         GetAssociatedDataFromEncryptedPacket(
             packet,
             header.public_header.connection_id_length,
             header.public_header.version_flag,
             header.public_header.sequence_number_length),
         encrypted));
-    if (decrypted_.get() != NULL) {
+    if (decrypted_.get() != nullptr) {
       visitor_->OnDecryptedPacket(alternative_decrypter_level_);
       if (alternative_decrypter_latch_) {
         // Switch to the alternative decrypter and latch so that we cannot
         // switch back.
         decrypter_.reset(alternative_decrypter_.release());
         decrypter_level_ = alternative_decrypter_level_;
         alternative_decrypter_level_ = ENCRYPTION_NONE;
       } else {
         // Switch the alternative decrypter so that we use it first next time.
         decrypter_.swap(alternative_decrypter_);
         EncryptionLevel level = alternative_decrypter_level_;
         alternative_decrypter_level_ = decrypter_level_;
         decrypter_level_ = level;
       }
     }
   }
 
-  if  (decrypted_.get() == NULL) {
+  if (decrypted_.get() == nullptr) {
     DLOG(WARNING) << "DecryptPacket failed for sequence_number:"
                   << header.packet_sequence_number;
     return false;
   }
 
   reader_.reset(new QuicDataReader(decrypted_->data(), decrypted_->length()));
   return true;
 }
 
 size_t QuicFramer::GetAckFrameSize(
@@ skipping 96 matching lines @@
   DCHECK(false);
   return 0;
 }
 
 bool QuicFramer::AppendTypeByte(const QuicFrame& frame,
                                 bool no_stream_frame_length,
                                 QuicDataWriter* writer) {
   uint8 type_byte = 0;
   switch (frame.type) {
     case STREAM_FRAME: {
-      if (frame.stream_frame == NULL) {
+      if (frame.stream_frame == nullptr) {
         LOG(DFATAL) << "Failed to append STREAM frame with no stream_frame.";
       }
       // Fin bit.
       type_byte |= frame.stream_frame->fin ? kQuicStreamFinMask : 0;
 
       // Data Length bit.
       type_byte <<= kQuicStreamDataLengthShift;
       type_byte |= no_stream_frame_length ? 0: kQuicStreamDataLengthMask;
 
       // Offset 3 bits.
@@ skipping 423 matching lines @@
   if (!writer->WriteUInt32(stream_id)) {
     return false;
   }
   return true;
 }
 
 bool QuicFramer::RaiseError(QuicErrorCode error) {
   DVLOG(1) << "Error detail: " << detailed_error_;
   set_error(error);
   visitor_->OnError(this);
-  reader_.reset(NULL);
+  reader_.reset(nullptr);
   return false;
 }
 
 }  // namespace net