text: // Copyright (c) 2016 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.
  
  #ifndef QUICHE_QUIC_CORE_FRAMES_QUIC_FRAME_H_
  #define QUICHE_QUIC_CORE_FRAMES_QUIC_FRAME_H_
  
  #include <ostream>
  #include <type_traits>
  #include <vector>
  
  #include "absl/container/inlined_vector.h"
  #include "quiche/quic/core/frames/quic_ack_frame.h"
  #include "quiche/quic/core/frames/quic_ack_frequency_frame.h"
  #include "quiche/quic/core/frames/quic_blocked_frame.h"
  #include "quiche/quic/core/frames/quic_connection_close_frame.h"
  #include "quiche/quic/core/frames/quic_crypto_frame.h"
  #include "quiche/quic/core/frames/quic_goaway_frame.h"
  #include "quiche/quic/core/frames/quic_handshake_done_frame.h"
  #include "quiche/quic/core/frames/quic_max_streams_frame.h"
  #include "quiche/quic/core/frames/quic_message_frame.h"
  #include "quiche/quic/core/frames/quic_mtu_discovery_frame.h"
  #include "quiche/quic/core/frames/quic_new_connection_id_frame.h"
  #include "quiche/quic/core/frames/quic_new_token_frame.h"
  #include "quiche/quic/core/frames/quic_padding_frame.h"
  #include "quiche/quic/core/frames/quic_path_challenge_frame.h"
  #include "quiche/quic/core/frames/quic_path_response_frame.h"
  #include "quiche/quic/core/frames/quic_ping_frame.h"
  #include "quiche/quic/core/frames/quic_retire_connection_id_frame.h"
  #include "quiche/quic/core/frames/quic_rst_stream_frame.h"
  #include "quiche/quic/core/frames/quic_stop_sending_frame.h"
  #include "quiche/quic/core/frames/quic_stop_waiting_frame.h"
  #include "quiche/quic/core/frames/quic_stream_frame.h"
  #include "quiche/quic/core/frames/quic_streams_blocked_frame.h"
  #include "quiche/quic/core/frames/quic_window_update_frame.h"
  #include "quiche/quic/core/quic_types.h"
  #include "quiche/quic/platform/api/quic_export.h"
  
  #ifndef QUIC_FRAME_DEBUG
  #if !defined(NDEBUG) || defined(ADDRESS_SANITIZER)
  #define QUIC_FRAME_DEBUG 1
  #else  // !defined(NDEBUG) || defined(ADDRESS_SANITIZER)
  #define QUIC_FRAME_DEBUG 0
  #endif  // !defined(NDEBUG) || defined(ADDRESS_SANITIZER)
  #endif  // QUIC_FRAME_DEBUG
  
  namespace quic {
  
  struct QUIC_EXPORT_PRIVATE QuicFrame {
    QuicFrame();
    // Please keep the constructors in the same order as the union below.
    explicit QuicFrame(QuicPaddingFrame padding_frame);
    explicit QuicFrame(QuicMtuDiscoveryFrame frame);
    explicit QuicFrame(QuicPingFrame frame);
    explicit QuicFrame(QuicMaxStreamsFrame frame);
    explicit QuicFrame(QuicStopWaitingFrame frame);
    explicit QuicFrame(QuicStreamsBlockedFrame frame);
    explicit QuicFrame(QuicStreamFrame stream_frame);
    explicit QuicFrame(QuicHandshakeDoneFrame handshake_done_frame);
    explicit QuicFrame(QuicWindowUpdateFrame frame);
    explicit QuicFrame(QuicBlockedFrame frame);
    explicit QuicFrame(QuicStopSendingFrame frame);
    explicit QuicFrame(QuicPathChallengeFrame frame);
    explicit QuicFrame(QuicPathResponseFrame frame);
  
    explicit QuicFrame(QuicAckFrame* frame);
    explicit QuicFrame(QuicRstStreamFrame* frame);
    explicit QuicFrame(QuicConnectionCloseFrame* frame);
    explicit QuicFrame(QuicGoAwayFrame* frame);
    explicit QuicFrame(QuicNewConnectionIdFrame* frame);
    explicit QuicFrame(QuicRetireConnectionIdFrame* frame);
    explicit QuicFrame(QuicNewTokenFrame* frame);
    explicit QuicFrame(QuicMessageFrame* message_frame);
    explicit QuicFrame(QuicCryptoFrame* crypto_frame);
    explicit QuicFrame(QuicAckFrequencyFrame* ack_frequency_frame);
  
    QUIC_EXPORT_PRIVATE friend std::ostream& operator<<(std::ostream& os,
                                                        const QuicFrame& frame);
  
    union {
      // Inlined frames.
      // Overlapping inlined frames have a |type| field at the same 0 offset as
      // QuicFrame does for out of line frames below, allowing use of the
      // remaining 7 bytes after offset for frame-type specific fields.
      QuicPaddingFrame padding_frame;
      QuicMtuDiscoveryFrame mtu_discovery_frame;
      QuicPingFrame ping_frame;
      QuicMaxStreamsFrame max_streams_frame;
      QuicStopWaitingFrame stop_waiting_frame;
      QuicStreamsBlockedFrame streams_blocked_frame;
      QuicStreamFrame stream_frame;
      QuicHandshakeDoneFrame handshake_done_frame;
      QuicWindowUpdateFrame window_update_frame;
      QuicBlockedFrame blocked_frame;
      QuicStopSendingFrame stop_sending_frame;
      QuicPathChallengeFrame path_challenge_frame;
      QuicPathResponseFrame path_response_frame;
  
      // Out of line frames.
      struct {
        QuicFrameType type;
  
  #if QUIC_FRAME_DEBUG
        bool delete_forbidden = false;
  #endif  // QUIC_FRAME_DEBUG
  
        union {
          QuicAckFrame* ack_frame;
          QuicRstStreamFrame* rst_stream_frame;
          QuicConnectionCloseFrame* connection_close_frame;
          QuicGoAwayFrame* goaway_frame;
          QuicNewConnectionIdFrame* new_connection_id_frame;
          QuicRetireConnectionIdFrame* retire_connection_id_frame;
          QuicMessageFrame* message_frame;
          QuicCryptoFrame* crypto_frame;
          QuicAckFrequencyFrame* ack_frequency_frame;
          QuicNewTokenFrame* new_token_frame;
        };
      };
    };
  };
  
  static_assert(std::is_standard_layout<QuicFrame>::value,
                "QuicFrame must have a standard layout");
  static_assert(sizeof(QuicFrame) <= 24,
                "Frames larger than 24 bytes should be referenced by pointer.");
  static_assert(offsetof(QuicStreamFrame, type) == offsetof(QuicFrame, type),
                "Offset of |type| must match in QuicFrame and QuicStreamFrame");
  
  // A inline size of 1 is chosen to optimize the typical use case of
  // 1-stream-frame in QuicTransmissionInfo.retransmittable_frames.
  using QuicFrames = absl::InlinedVector<QuicFrame, 1>;
  
  // Deletes all the sub-frames contained in |frames|.
  QUIC_EXPORT_PRIVATE void DeleteFrames(QuicFrames* frames);
  
  // Delete the sub-frame contained in |frame|.
  QUIC_EXPORT_PRIVATE void DeleteFrame(QuicFrame* frame);
  
  // Deletes all the QuicStreamFrames for the specified |stream_id|.
  QUIC_EXPORT_PRIVATE void RemoveFramesForStream(QuicFrames* frames,
                                                 QuicStreamId stream_id);
  
  // Returns true if |type| is a retransmittable control frame.
  QUIC_EXPORT_PRIVATE bool IsControlFrame(QuicFrameType type);
  
  // Returns control_frame_id of |frame|. Returns kInvalidControlFrameId if
  // |frame| does not have a valid control_frame_id.
  QUIC_EXPORT_PRIVATE QuicControlFrameId
  GetControlFrameId(const QuicFrame& frame);
  
  // Sets control_frame_id of |frame| to |control_frame_id|.
  QUIC_EXPORT_PRIVATE void SetControlFrameId(QuicControlFrameId control_frame_id,
                                             QuicFrame* frame);
  
  // Returns a copy of |frame|.
  QUIC_EXPORT_PRIVATE QuicFrame
  CopyRetransmittableControlFrame(const QuicFrame& frame);
  
  // Returns a copy of |frame|.
  QUIC_EXPORT_PRIVATE QuicFrame
  CopyQuicFrame(quiche::QuicheBufferAllocator* allocator, const QuicFrame& frame);
  
  // Returns a copy of |frames|.
  QUIC_EXPORT_PRIVATE QuicFrames CopyQuicFrames(
      quiche::QuicheBufferAllocator* allocator, const QuicFrames& frames);
  
  // Human-readable description suitable for logging.
  QUIC_EXPORT_PRIVATE std::string QuicFramesToString(const QuicFrames& frames);
  
  }  // namespace quic
  
  #endif  // QUICHE_QUIC_CORE_FRAMES_QUIC_FRAME_H_
  