relnote: Change the QuicBlockedFrame in QuicFrame from a pointer to in-place. No functional change.

net/quic/quic_protocol.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_protocol.h"
 
 #include "base/stl_util.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_utils.h"
 
@@ skipping 328 matching lines @@
 
 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame)
     : type(CONNECTION_CLOSE_FRAME), connection_close_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicGoAwayFrame* frame)
     : type(GOAWAY_FRAME), goaway_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
     : type(WINDOW_UPDATE_FRAME), window_update_frame(frame) {}
 
-QuicFrame::QuicFrame(QuicBlockedFrame* frame)
+QuicFrame::QuicFrame(QuicBlockedFrame frame)
     : type(BLOCKED_FRAME), blocked_frame(frame) {}
 
 ostream& operator<<(ostream& os, const QuicStopWaitingFrame& sent_info) {
   os << "entropy_hash: " << static_cast<int>(sent_info.entropy_hash)
      << " least_unacked: " << sent_info.least_unacked;
   return os;
 }
 
 PacketNumberQueue::const_iterator::const_iterator(
     IntervalSet<QuicPacketNumber>::const_iterator interval_set_iter,
@@ skipping 191 matching lines @@
     }
     case GOAWAY_FRAME: {
       os << "type { GOAWAY_FRAME } " << *(frame.goaway_frame);
       break;
     }
     case WINDOW_UPDATE_FRAME: {
       os << "type { WINDOW_UPDATE_FRAME } " << *(frame.window_update_frame);
       break;
     }
     case BLOCKED_FRAME: {
-      os << "type { BLOCKED_FRAME } " << *(frame.blocked_frame);
+      os << "type { BLOCKED_FRAME } " << frame.blocked_frame;
       break;
     }
     case STREAM_FRAME: {
       os << "type { STREAM_FRAME } " << *(frame.stream_frame);
       break;
     }
     case ACK_FRAME: {
       os << "type { ACK_FRAME } " << *(frame.ack_frame);
       break;
     }
@@ skipping 134 matching lines @@
   frames_.reserve(2);
 }
 
 RetransmittableFrames::~RetransmittableFrames() {
   for (QuicFrame& frame : frames_) {
     switch (frame.type) {
       // Frames smaller than a pointer are inlined, so don't need to be deleted.
       case PADDING_FRAME:
       case MTU_DISCOVERY_FRAME:
       case PING_FRAME:
+      case BLOCKED_FRAME:
         break;
       case STREAM_FRAME:
         delete frame.stream_frame;
         break;
       case ACK_FRAME:
         delete frame.ack_frame;
         break;
       case STOP_WAITING_FRAME:
         delete frame.stop_waiting_frame;
         break;
       case RST_STREAM_FRAME:
         delete frame.rst_stream_frame;
         break;
       case CONNECTION_CLOSE_FRAME:
         delete frame.connection_close_frame;
         break;
       case GOAWAY_FRAME:
         delete frame.goaway_frame;
         break;
       case WINDOW_UPDATE_FRAME:
         delete frame.window_update_frame;
         break;
-      case BLOCKED_FRAME:
-        delete frame.blocked_frame;
-        break;
       case NUM_FRAME_TYPES:
         DCHECK(false) << "Cannot delete type: " << frame.type;
     }
   }
 }
 
 const QuicFrame& RetransmittableFrames::AddFrame(const QuicFrame& frame) {
   if (frame.type == STREAM_FRAME &&
       frame.stream_frame->stream_id == kCryptoStreamId) {
     has_crypto_handshake_ = IS_HANDSHAKE;
@@ skipping 115 matching lines @@
       transmission_type(transmission_type),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(is_fec_packet),
       all_transmissions(nullptr),
       retransmission(0) {}
 
 TransmissionInfo::~TransmissionInfo() {}
 
 }  // namespace net