relnote: Inline all frames smaller than a pointer into QuicFrame.

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 248 matching lines @@
       byte_offset(bytes_written) {
   DCHECK_LE(error_code, numeric_limits<uint8>::max());
 }
 
 QuicConnectionCloseFrame::QuicConnectionCloseFrame()
     : error_code(QUIC_NO_ERROR) {
 }
 
 QuicFrame::QuicFrame() {}
 
-QuicFrame::QuicFrame(QuicPaddingFrame* padding_frame)
-    : type(PADDING_FRAME),
-      padding_frame(padding_frame) {
-}
+QuicFrame::QuicFrame(QuicPaddingFrame padding_frame)
+    : type(PADDING_FRAME), padding_frame(padding_frame) {}
 
 QuicFrame::QuicFrame(QuicStreamFrame* stream_frame)
-    : type(STREAM_FRAME),
-      stream_frame(stream_frame) {
-}
+    : type(STREAM_FRAME), stream_frame(stream_frame) {}
 
-QuicFrame::QuicFrame(QuicAckFrame* frame)
-    : type(ACK_FRAME),
-      ack_frame(frame) {
-}
+QuicFrame::QuicFrame(QuicAckFrame* frame) : type(ACK_FRAME), ack_frame(frame) {}
 
-QuicFrame::QuicFrame(QuicMtuDiscoveryFrame* frame)
-    : type(MTU_DISCOVERY_FRAME), mtu_discovery_frame(frame) {
-}
+QuicFrame::QuicFrame(QuicMtuDiscoveryFrame frame)
+    : type(MTU_DISCOVERY_FRAME), mtu_discovery_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicStopWaitingFrame* frame)
-    : type(STOP_WAITING_FRAME),
-      stop_waiting_frame(frame) {
-}
+    : type(STOP_WAITING_FRAME), stop_waiting_frame(frame) {}
 
-QuicFrame::QuicFrame(QuicPingFrame* frame)
-    : type(PING_FRAME),
-      ping_frame(frame) {
-}
+QuicFrame::QuicFrame(QuicPingFrame frame)
+    : type(PING_FRAME), ping_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicRstStreamFrame* frame)
-    : type(RST_STREAM_FRAME),
-      rst_stream_frame(frame) {
-}
+    : type(RST_STREAM_FRAME), rst_stream_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicConnectionCloseFrame* frame)
-    : type(CONNECTION_CLOSE_FRAME),
-      connection_close_frame(frame) {
-}
+    : type(CONNECTION_CLOSE_FRAME), connection_close_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicGoAwayFrame* frame)
-    : type(GOAWAY_FRAME),
-      goaway_frame(frame) {
-}
+    : type(GOAWAY_FRAME), goaway_frame(frame) {}
 
 QuicFrame::QuicFrame(QuicWindowUpdateFrame* frame)
-    : type(WINDOW_UPDATE_FRAME),
-      window_update_frame(frame) {
-}
+    : type(WINDOW_UPDATE_FRAME), window_update_frame(frame) {}
 
-QuicFrame::QuicFrame(QuicBlockedFrame* frame)
-    : type(BLOCKED_FRAME),
-      blocked_frame(frame) {
-}
+QuicFrame::QuicFrame(QuicBlockedFrame frame)
+    : type(BLOCKED_FRAME), blocked_frame(frame) {}
 
 QuicFecData::QuicFecData() : fec_group(0) {}
 
 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(
@@ skipping 276 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 152 matching lines @@
                      length() - start_of_encrypted_data);
 }
 
 RetransmittableFrames::RetransmittableFrames(EncryptionLevel level)
     : encryption_level_(level),
       has_crypto_handshake_(NOT_HANDSHAKE),
       needs_padding_(false) {
 }
 
 RetransmittableFrames::~RetransmittableFrames() {
-  for (QuicFrames::iterator it = frames_.begin(); it != frames_.end(); ++it) {
-    switch (it->type) {
+  for (QuicFrame& frame : frames_) {
+    switch (frame.type) {
+      // Frames smaller than a pointer are inlined, so don't need to be deleted.
       case PADDING_FRAME:
-        delete it->padding_frame;
+      case MTU_DISCOVERY_FRAME:
+      case PING_FRAME:
+      case BLOCKED_FRAME:
         break;
       case STREAM_FRAME:
-        delete it->stream_frame;
+        delete frame.stream_frame;
         break;
       case ACK_FRAME:
-        delete it->ack_frame;
-        break;
-      case MTU_DISCOVERY_FRAME:
-        delete it->mtu_discovery_frame;
+        delete frame.ack_frame;
         break;
       case STOP_WAITING_FRAME:
-        delete it->stop_waiting_frame;
-        break;
-      case PING_FRAME:
-        delete it->ping_frame;
+        delete frame.stop_waiting_frame;
         break;
       case RST_STREAM_FRAME:
-        delete it->rst_stream_frame;
+        delete frame.rst_stream_frame;
         break;
       case CONNECTION_CLOSE_FRAME:
-        delete it->connection_close_frame;
+        delete frame.connection_close_frame;
         break;
       case GOAWAY_FRAME:
-        delete it->goaway_frame;
+        delete frame.goaway_frame;
         break;
       case WINDOW_UPDATE_FRAME:
-        delete it->window_update_frame;
-        break;
-      case BLOCKED_FRAME:
-        delete it->blocked_frame;
+        delete frame.window_update_frame;
         break;
       case NUM_FRAME_TYPES:
-        DCHECK(false) << "Cannot delete type: " << it->type;
+        DCHECK(false) << "Cannot delete type: " << frame.type;
     }
   }
   // TODO(rtenneti): Delete the for loop once chrome has c++11 library support
   // for "std::vector<UniqueStreamBuffer> stream_data_;".
   for (const char* buffer : stream_data_) {
     delete[] buffer;
   }
 }
 
 const QuicFrame& RetransmittableFrames::AddFrame(const QuicFrame& frame) {
@@ skipping 79 matching lines @@
       bytes_sent(bytes_sent),
       nack_count(0),
       sent_time(sent_time),
       transmission_type(transmission_type),
       in_flight(false),
       is_unackable(false),
       is_fec_packet(is_fec_packet),
       all_transmissions(nullptr) {}
 
 }  // namespace net