Use QpackEncoder::InstructionWithValues to refactor QpackInstructionEncoder interface.
This change is inspired by rch's suggestion at cr/258561443.
gfe-relnote: n/a, change to QUIC v99-only code. Protected by existing disabled gfe2_reloadable_flag_quic_enable_version_99.
PiperOrigin-RevId: 277699504
Change-Id: Iebde22504ae29f2307433458defb9f308bc5cb64
diff --git a/quic/core/qpack/qpack_constants.cc b/quic/core/qpack/qpack_constants.cc
index 6644918..1e43060 100644
--- a/quic/core/qpack/qpack_constants.cc
+++ b/quic/core/qpack/qpack_constants.cc
@@ -199,4 +199,133 @@
return language;
}
+// static
+QpackInstructionWithValues QpackInstructionWithValues::InsertWithNameReference(
+ bool is_static,
+ uint64_t name_index,
+ QuicStringPiece value) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = InsertWithNameReferenceInstruction();
+ instruction_with_values.s_bit_ = is_static;
+ instruction_with_values.varint_ = name_index;
+ instruction_with_values.value_ = value;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues
+QpackInstructionWithValues::InsertWithoutNameReference(QuicStringPiece name,
+ QuicStringPiece value) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ =
+ InsertWithoutNameReferenceInstruction();
+ instruction_with_values.name_ = name;
+ instruction_with_values.value_ = value;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::Duplicate(
+ uint64_t index) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = DuplicateInstruction();
+ instruction_with_values.varint_ = index;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::SetDynamicTableCapacity(
+ uint64_t capacity) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = SetDynamicTableCapacityInstruction();
+ instruction_with_values.varint_ = capacity;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::InsertCountIncrement(
+ uint64_t increment) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = InsertCountIncrementInstruction();
+ instruction_with_values.varint_ = increment;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::HeaderAcknowledgement(
+ uint64_t stream_id) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = HeaderAcknowledgementInstruction();
+ instruction_with_values.varint_ = stream_id;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::StreamCancellation(
+ uint64_t stream_id) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = StreamCancellationInstruction();
+ instruction_with_values.varint_ = stream_id;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::Prefix(
+ uint64_t required_insert_count) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = QpackPrefixInstruction();
+ instruction_with_values.varint_ = required_insert_count;
+ instruction_with_values.varint2_ = 0; // Delta Base.
+ instruction_with_values.s_bit_ = false; // Delta Base sign.
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::IndexedHeaderField(
+ bool is_static,
+ uint64_t index) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = QpackIndexedHeaderFieldInstruction();
+ instruction_with_values.s_bit_ = is_static;
+ instruction_with_values.varint_ = index;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues
+QpackInstructionWithValues::LiteralHeaderFieldNameReference(
+ bool is_static,
+ uint64_t index,
+ QuicStringPiece value) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ =
+ QpackLiteralHeaderFieldNameReferenceInstruction();
+ instruction_with_values.s_bit_ = is_static;
+ instruction_with_values.varint_ = index;
+ instruction_with_values.value_ = value;
+
+ return instruction_with_values;
+}
+
+// static
+QpackInstructionWithValues QpackInstructionWithValues::LiteralHeaderField(
+ QuicStringPiece name,
+ QuicStringPiece value) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = QpackLiteralHeaderFieldInstruction();
+ instruction_with_values.name_ = name;
+ instruction_with_values.value_ = value;
+
+ return instruction_with_values;
+}
+
} // namespace quic
diff --git a/quic/core/qpack/qpack_constants.h b/quic/core/qpack/qpack_constants.h
index 35e4d56..2604e37 100644
--- a/quic/core/qpack/qpack_constants.h
+++ b/quic/core/qpack/qpack_constants.h
@@ -11,9 +11,14 @@
#include <vector>
#include "net/third_party/quiche/src/quic/platform/api/quic_export.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_string_piece.h"
namespace quic {
+namespace test {
+class QpackInstructionWithValuesPeer;
+} // namespace test
+
// Each instruction is identified with an opcode in the first byte.
// |mask| determines which bits are part of the opcode.
// |value| is the value of these bits. (Other bits in value must be zero.)
@@ -137,6 +142,66 @@
// Request and push stream language.
const QpackLanguage* QpackRequestStreamLanguage();
+// Storage for instruction and field values to be encoded.
+// This class can only be instantiated using factory methods that take exactly
+// the arguments that the corresponding instruction needs.
+class QUIC_EXPORT_PRIVATE QpackInstructionWithValues {
+ public:
+ // 5.2 Encoder stream instructions
+ static QpackInstructionWithValues InsertWithNameReference(
+ bool is_static,
+ uint64_t name_index,
+ QuicStringPiece value);
+ static QpackInstructionWithValues InsertWithoutNameReference(
+ QuicStringPiece name,
+ QuicStringPiece value);
+ static QpackInstructionWithValues Duplicate(uint64_t index);
+ static QpackInstructionWithValues SetDynamicTableCapacity(uint64_t capacity);
+
+ // 5.3 Decoder stream instructions
+ static QpackInstructionWithValues InsertCountIncrement(uint64_t increment);
+ static QpackInstructionWithValues HeaderAcknowledgement(uint64_t stream_id);
+ static QpackInstructionWithValues StreamCancellation(uint64_t stream_id);
+
+ // 5.4.1. Header data prefix. Delta Base is hardcoded to be zero.
+ static QpackInstructionWithValues Prefix(uint64_t required_insert_count);
+
+ // 5.4.2. Request and push stream instructions
+ static QpackInstructionWithValues IndexedHeaderField(bool is_static,
+ uint64_t index);
+ static QpackInstructionWithValues LiteralHeaderFieldNameReference(
+ bool is_static,
+ uint64_t index,
+ QuicStringPiece value);
+ static QpackInstructionWithValues LiteralHeaderField(QuicStringPiece name,
+ QuicStringPiece value);
+
+ const QpackInstruction* instruction() const { return instruction_; }
+ bool s_bit() const { return s_bit_; }
+ uint64_t varint() const { return varint_; }
+ uint64_t varint2() const { return varint2_; }
+ QuicStringPiece name() const { return name_; }
+ QuicStringPiece value() const { return value_; }
+
+ // Used by QpackEncoder, because in the first pass it stores absolute indices,
+ // which are converted into relative indices in the second pass after base is
+ // determined.
+ void set_varint(uint64_t varint) { varint_ = varint; }
+
+ private:
+ friend test::QpackInstructionWithValuesPeer;
+
+ QpackInstructionWithValues() = default;
+
+ // |*instruction| is not owned.
+ const QpackInstruction* instruction_;
+ bool s_bit_;
+ uint64_t varint_;
+ uint64_t varint2_;
+ QuicStringPiece name_;
+ QuicStringPiece value_;
+};
+
} // namespace quic
#endif // QUICHE_QUIC_CORE_QPACK_QPACK_CONSTANTS_H_
diff --git a/quic/core/qpack/qpack_decoder_stream_sender.cc b/quic/core/qpack/qpack_decoder_stream_sender.cc
index 68e4d67..078a54e 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender.cc
+++ b/quic/core/qpack/qpack_decoder_stream_sender.cc
@@ -16,25 +16,19 @@
QpackDecoderStreamSender::QpackDecoderStreamSender() : delegate_(nullptr) {}
void QpackDecoderStreamSender::SendInsertCountIncrement(uint64_t increment) {
- values_.varint = increment;
-
- instruction_encoder_.Encode(InsertCountIncrementInstruction(), values_,
- &buffer_);
+ instruction_encoder_.Encode(
+ QpackInstructionWithValues::InsertCountIncrement(increment), &buffer_);
}
void QpackDecoderStreamSender::SendHeaderAcknowledgement(
QuicStreamId stream_id) {
- values_.varint = stream_id;
-
- instruction_encoder_.Encode(HeaderAcknowledgementInstruction(), values_,
- &buffer_);
+ instruction_encoder_.Encode(
+ QpackInstructionWithValues::HeaderAcknowledgement(stream_id), &buffer_);
}
void QpackDecoderStreamSender::SendStreamCancellation(QuicStreamId stream_id) {
- values_.varint = stream_id;
-
- instruction_encoder_.Encode(StreamCancellationInstruction(), values_,
- &buffer_);
+ instruction_encoder_.Encode(
+ QpackInstructionWithValues::StreamCancellation(stream_id), &buffer_);
}
void QpackDecoderStreamSender::Flush() {
diff --git a/quic/core/qpack/qpack_decoder_stream_sender.h b/quic/core/qpack/qpack_decoder_stream_sender.h
index 93d95d9..d9033b0 100644
--- a/quic/core/qpack/qpack_decoder_stream_sender.h
+++ b/quic/core/qpack/qpack_decoder_stream_sender.h
@@ -44,7 +44,6 @@
private:
QpackStreamSenderDelegate* delegate_;
QpackInstructionEncoder instruction_encoder_;
- QpackInstructionEncoder::Values values_;
std::string buffer_;
};
diff --git a/quic/core/qpack/qpack_encoder.cc b/quic/core/qpack/qpack_encoder.cc
index 599c575..c47dccd 100644
--- a/quic/core/qpack/qpack_encoder.cc
+++ b/quic/core/qpack/qpack_encoder.cc
@@ -7,7 +7,6 @@
#include <algorithm>
#include <utility>
-#include "net/third_party/quiche/src/quic/core/qpack/qpack_constants.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_index_conversions.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_instruction_encoder.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_required_insert_count.h"
@@ -42,47 +41,37 @@
QpackEncoder::~QpackEncoder() {}
// static
-QpackEncoder::InstructionWithValues QpackEncoder::EncodeIndexedHeaderField(
+QpackInstructionWithValues QpackEncoder::EncodeIndexedHeaderField(
bool is_static,
uint64_t index,
QpackBlockingManager::IndexSet* referred_indices) {
- InstructionWithValues instruction{QpackIndexedHeaderFieldInstruction(), {}};
- instruction.values.s_bit = is_static;
- instruction.values.varint = index;
// Add |index| to |*referred_indices| only if entry is in the dynamic table.
if (!is_static) {
referred_indices->insert(index);
}
- return instruction;
+ return QpackInstructionWithValues::IndexedHeaderField(is_static, index);
}
// static
-QpackEncoder::InstructionWithValues
+QpackInstructionWithValues
QpackEncoder::EncodeLiteralHeaderFieldWithNameReference(
bool is_static,
uint64_t index,
QuicStringPiece value,
QpackBlockingManager::IndexSet* referred_indices) {
- InstructionWithValues instruction{
- QpackLiteralHeaderFieldNameReferenceInstruction(), {}};
- instruction.values.s_bit = is_static;
- instruction.values.varint = index;
- instruction.values.value = value;
// Add |index| to |*referred_indices| only if entry is in the dynamic table.
if (!is_static) {
referred_indices->insert(index);
}
- return instruction;
+ return QpackInstructionWithValues::LiteralHeaderFieldNameReference(
+ is_static, index, value);
}
// static
-QpackEncoder::InstructionWithValues QpackEncoder::EncodeLiteralHeaderField(
+QpackInstructionWithValues QpackEncoder::EncodeLiteralHeaderField(
QuicStringPiece name,
QuicStringPiece value) {
- InstructionWithValues instruction{QpackLiteralHeaderFieldInstruction(), {}};
- instruction.values.name = name;
- instruction.values.value = value;
- return instruction;
+ return QpackInstructionWithValues::LiteralHeaderField(name, value);
}
QpackEncoder::Instructions QpackEncoder::FirstPassEncode(
@@ -325,29 +314,24 @@
std::string encoded_headers;
// Header block prefix.
- QpackInstructionEncoder::Values values;
- values.varint = QpackEncodeRequiredInsertCount(required_insert_count,
- header_table_.max_entries());
- values.varint2 = 0; // Delta Base.
- values.s_bit = false; // Delta Base sign.
- const uint64_t base = required_insert_count;
+ instruction_encoder.Encode(
+ QpackInstructionWithValues::Prefix(QpackEncodeRequiredInsertCount(
+ required_insert_count, header_table_.max_entries())),
+ &encoded_headers);
- instruction_encoder.Encode(QpackPrefixInstruction(), values,
- &encoded_headers);
+ const uint64_t base = required_insert_count;
for (auto& instruction : instructions) {
// Dynamic table references must be transformed from absolute to relative
// indices.
- if ((instruction.instruction == QpackIndexedHeaderFieldInstruction() ||
- instruction.instruction ==
+ if ((instruction.instruction() == QpackIndexedHeaderFieldInstruction() ||
+ instruction.instruction() ==
QpackLiteralHeaderFieldNameReferenceInstruction()) &&
- !instruction.values.s_bit) {
- instruction.values.varint =
- QpackAbsoluteIndexToRequestStreamRelativeIndex(
- instruction.values.varint, base);
+ !instruction.s_bit()) {
+ instruction.set_varint(QpackAbsoluteIndexToRequestStreamRelativeIndex(
+ instruction.varint(), base));
}
- instruction_encoder.Encode(instruction.instruction, instruction.values,
- &encoded_headers);
+ instruction_encoder.Encode(instruction, &encoded_headers);
}
return encoded_headers;
diff --git a/quic/core/qpack/qpack_encoder.h b/quic/core/qpack/qpack_encoder.h
index 22232e6..0e40ddf 100644
--- a/quic/core/qpack/qpack_encoder.h
+++ b/quic/core/qpack/qpack_encoder.h
@@ -11,6 +11,7 @@
#include <vector>
#include "net/third_party/quiche/src/quic/core/qpack/qpack_blocking_manager.h"
+#include "net/third_party/quiche/src/quic/core/qpack/qpack_constants.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_decoder_stream_receiver.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_encoder_stream_sender.h"
#include "net/third_party/quiche/src/quic/core/qpack/qpack_header_table.h"
@@ -90,36 +91,27 @@
private:
friend class test::QpackEncoderPeer;
- // TODO(bnc): Consider moving this class to QpackInstructionEncoder or
- // qpack_constants, adding factory methods, one for each instruction, and
- // changing QpackInstructionEncoder::Encoder() to take an
- // InstructionWithValues struct instead of separate |instruction| and |values|
- // arguments.
- struct QUIC_EXPORT_PRIVATE InstructionWithValues {
- // |instruction| is not owned.
- const QpackInstruction* instruction;
- QpackInstructionEncoder::Values values;
- };
- using Instructions = std::vector<InstructionWithValues>;
+ using Instructions = std::vector<QpackInstructionWithValues>;
// Generate indexed header field instruction
// and optionally update |*referred_indices|.
- static InstructionWithValues EncodeIndexedHeaderField(
+ static QpackInstructionWithValues EncodeIndexedHeaderField(
bool is_static,
uint64_t index,
QpackBlockingManager::IndexSet* referred_indices);
// Generate literal header field with name reference instruction
// and optionally update |*referred_indices|.
- static InstructionWithValues EncodeLiteralHeaderFieldWithNameReference(
+ static QpackInstructionWithValues EncodeLiteralHeaderFieldWithNameReference(
bool is_static,
uint64_t index,
QuicStringPiece value,
QpackBlockingManager::IndexSet* referred_indices);
// Generate literal header field instruction.
- static InstructionWithValues EncodeLiteralHeaderField(QuicStringPiece name,
- QuicStringPiece value);
+ static QpackInstructionWithValues EncodeLiteralHeaderField(
+ QuicStringPiece name,
+ QuicStringPiece value);
// Performs first pass of two-pass encoding: represent each header field in
// |*header_list| as a reference to an existing entry, the name of an existing
diff --git a/quic/core/qpack/qpack_encoder_stream_sender.cc b/quic/core/qpack/qpack_encoder_stream_sender.cc
index 4a7f12c..fc7c8fd 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender.cc
+++ b/quic/core/qpack/qpack_encoder_stream_sender.cc
@@ -19,35 +19,28 @@
bool is_static,
uint64_t name_index,
QuicStringPiece value) {
- values_.s_bit = is_static;
- values_.varint = name_index;
- values_.value = value;
-
- instruction_encoder_.Encode(InsertWithNameReferenceInstruction(), values_,
- &buffer_);
+ instruction_encoder_.Encode(
+ QpackInstructionWithValues::InsertWithNameReference(is_static, name_index,
+ value),
+ &buffer_);
}
void QpackEncoderStreamSender::SendInsertWithoutNameReference(
QuicStringPiece name,
QuicStringPiece value) {
- values_.name = name;
- values_.value = value;
-
- instruction_encoder_.Encode(InsertWithoutNameReferenceInstruction(), values_,
- &buffer_);
+ instruction_encoder_.Encode(
+ QpackInstructionWithValues::InsertWithoutNameReference(name, value),
+ &buffer_);
}
void QpackEncoderStreamSender::SendDuplicate(uint64_t index) {
- values_.varint = index;
-
- instruction_encoder_.Encode(DuplicateInstruction(), values_, &buffer_);
+ instruction_encoder_.Encode(QpackInstructionWithValues::Duplicate(index),
+ &buffer_);
}
void QpackEncoderStreamSender::SendSetDynamicTableCapacity(uint64_t capacity) {
- values_.varint = capacity;
-
- instruction_encoder_.Encode(SetDynamicTableCapacityInstruction(), values_,
- &buffer_);
+ instruction_encoder_.Encode(
+ QpackInstructionWithValues::SetDynamicTableCapacity(capacity), &buffer_);
}
QuicByteCount QpackEncoderStreamSender::Flush() {
diff --git a/quic/core/qpack/qpack_encoder_stream_sender.h b/quic/core/qpack/qpack_encoder_stream_sender.h
index efbfbc6..de9e8f1 100644
--- a/quic/core/qpack/qpack_encoder_stream_sender.h
+++ b/quic/core/qpack/qpack_encoder_stream_sender.h
@@ -50,7 +50,6 @@
private:
QpackStreamSenderDelegate* delegate_;
QpackInstructionEncoder instruction_encoder_;
- QpackInstructionEncoder::Values values_;
std::string buffer_;
};
diff --git a/quic/core/qpack/qpack_instruction_encoder.cc b/quic/core/qpack/qpack_instruction_encoder.cc
index 5845a74..a87489d 100644
--- a/quic/core/qpack/qpack_instruction_encoder.cc
+++ b/quic/core/qpack/qpack_instruction_encoder.cc
@@ -16,13 +16,13 @@
QpackInstructionEncoder::QpackInstructionEncoder()
: byte_(0), state_(State::kOpcode), instruction_(nullptr) {}
-void QpackInstructionEncoder::Encode(const QpackInstruction* instruction,
- const Values& values,
- std::string* output) {
- DCHECK(instruction);
+void QpackInstructionEncoder::Encode(
+ const QpackInstructionWithValues& instruction_with_values,
+ std::string* output) {
+ DCHECK(instruction_with_values.instruction());
state_ = State::kOpcode;
- instruction_ = instruction;
+ instruction_ = instruction_with_values.instruction();
field_ = instruction_->fields.begin();
// Field list must not be empty.
@@ -37,13 +37,15 @@
DoStartField();
break;
case State::kSbit:
- DoSBit(values.s_bit);
+ DoSBit(instruction_with_values.s_bit());
break;
case State::kVarintEncode:
- DoVarintEncode(values.varint, values.varint2, output);
+ DoVarintEncode(instruction_with_values.varint(),
+ instruction_with_values.varint2(), output);
break;
case State::kStartString:
- DoStartString(values.name, values.value);
+ DoStartString(instruction_with_values.name(),
+ instruction_with_values.value());
break;
case State::kWriteString:
DoWriteString(output);
diff --git a/quic/core/qpack/qpack_instruction_encoder.h b/quic/core/qpack/qpack_instruction_encoder.h
index 4f1392a..2a59953 100644
--- a/quic/core/qpack/qpack_instruction_encoder.h
+++ b/quic/core/qpack/qpack_instruction_encoder.h
@@ -19,23 +19,12 @@
// fields that follow each instruction.
class QUIC_EXPORT_PRIVATE QpackInstructionEncoder {
public:
- // Storage for field values to be encoded.
- // The encoded instruction determines which values are actually used.
- struct QUIC_EXPORT_PRIVATE Values {
- bool s_bit;
- uint64_t varint;
- uint64_t varint2;
- QuicStringPiece name;
- QuicStringPiece value;
- };
-
QpackInstructionEncoder();
QpackInstructionEncoder(const QpackInstructionEncoder&) = delete;
QpackInstructionEncoder& operator=(const QpackInstructionEncoder&) = delete;
// Append encoded instruction to |output|.
- void Encode(const QpackInstruction* instruction,
- const Values& values,
+ void Encode(const QpackInstructionWithValues& instruction_with_values,
std::string* output);
private:
diff --git a/quic/core/qpack/qpack_instruction_encoder_test.cc b/quic/core/qpack/qpack_instruction_encoder_test.cc
index abd1353..79dfe2a 100644
--- a/quic/core/qpack/qpack_instruction_encoder_test.cc
+++ b/quic/core/qpack/qpack_instruction_encoder_test.cc
@@ -10,6 +10,42 @@
namespace quic {
namespace test {
+
+class QpackInstructionWithValuesPeer {
+ public:
+ static QpackInstructionWithValues CreateQpackInstructionWithValues(
+ const QpackInstruction* instruction) {
+ QpackInstructionWithValues instruction_with_values;
+ instruction_with_values.instruction_ = instruction;
+ return instruction_with_values;
+ }
+
+ static void set_s_bit(QpackInstructionWithValues* instruction_with_values,
+ bool s_bit) {
+ instruction_with_values->s_bit_ = s_bit;
+ }
+
+ static void set_varint(QpackInstructionWithValues* instruction_with_values,
+ uint64_t varint) {
+ instruction_with_values->varint_ = varint;
+ }
+
+ static void set_varint2(QpackInstructionWithValues* instruction_with_values,
+ uint64_t varint2) {
+ instruction_with_values->varint2_ = varint2;
+ }
+
+ static void set_name(QpackInstructionWithValues* instruction_with_values,
+ QuicStringPiece name) {
+ instruction_with_values->name_ = name;
+ }
+
+ static void set_value(QpackInstructionWithValues* instruction_with_values,
+ QuicStringPiece value) {
+ instruction_with_values->value_ = value;
+ }
+};
+
namespace {
class QpackInstructionEncoderTest : public QuicTest {
@@ -18,9 +54,9 @@
~QpackInstructionEncoderTest() override = default;
// Append encoded |instruction| to |output_|.
- void EncodeInstruction(const QpackInstruction* instruction,
- const QpackInstructionEncoder::Values& values) {
- encoder_.Encode(instruction, values, &output_);
+ void EncodeInstruction(
+ const QpackInstructionWithValues& instruction_with_values) {
+ encoder_.Encode(instruction_with_values, &output_);
}
// Compare substring appended to |output_| since last EncodedSegmentMatches()
@@ -42,13 +78,15 @@
const QpackInstruction instruction{QpackInstructionOpcode{0x00, 0x80},
{{QpackInstructionFieldType::kVarint, 7}}};
- QpackInstructionEncoder::Values values;
- values.varint = 5;
- EncodeInstruction(&instruction, values);
+ auto instruction_with_values =
+ QpackInstructionWithValuesPeer::CreateQpackInstructionWithValues(
+ &instruction);
+ QpackInstructionWithValuesPeer::set_varint(&instruction_with_values, 5);
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("05"));
- values.varint = 127;
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_varint(&instruction_with_values, 127);
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("7f00"));
}
@@ -59,17 +97,19 @@
{QpackInstructionFieldType::kVarint, 5},
{QpackInstructionFieldType::kVarint2, 8}}};
- QpackInstructionEncoder::Values values;
- values.s_bit = true;
- values.varint = 5;
- values.varint2 = 200;
- EncodeInstruction(&instruction, values);
+ auto instruction_with_values =
+ QpackInstructionWithValuesPeer::CreateQpackInstructionWithValues(
+ &instruction);
+ QpackInstructionWithValuesPeer::set_s_bit(&instruction_with_values, true);
+ QpackInstructionWithValuesPeer::set_varint(&instruction_with_values, 5);
+ QpackInstructionWithValuesPeer::set_varint2(&instruction_with_values, 200);
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("a5c8"));
- values.s_bit = false;
- values.varint = 31;
- values.varint2 = 356;
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_s_bit(&instruction_with_values, false);
+ QpackInstructionWithValuesPeer::set_varint(&instruction_with_values, 31);
+ QpackInstructionWithValuesPeer::set_varint2(&instruction_with_values, 356);
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("9f00ff65"));
}
@@ -79,17 +119,19 @@
{QpackInstructionFieldType::kVarint, 5},
{QpackInstructionFieldType::kValue, 7}}};
- QpackInstructionEncoder::Values values;
- values.s_bit = true;
- values.varint = 100;
- values.value = "foo";
- EncodeInstruction(&instruction, values);
+ auto instruction_with_values =
+ QpackInstructionWithValuesPeer::CreateQpackInstructionWithValues(
+ &instruction);
+ QpackInstructionWithValuesPeer::set_s_bit(&instruction_with_values, true);
+ QpackInstructionWithValuesPeer::set_varint(&instruction_with_values, 100);
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "foo");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("ff458294e7"));
- values.s_bit = false;
- values.varint = 3;
- values.value = "bar";
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_s_bit(&instruction_with_values, false);
+ QpackInstructionWithValuesPeer::set_varint(&instruction_with_values, 3);
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "bar");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("c303626172"));
}
@@ -97,17 +139,19 @@
const QpackInstruction instruction{QpackInstructionOpcode{0xe0, 0xe0},
{{QpackInstructionFieldType::kName, 4}}};
- QpackInstructionEncoder::Values values;
- values.name = "";
- EncodeInstruction(&instruction, values);
+ auto instruction_with_values =
+ QpackInstructionWithValuesPeer::CreateQpackInstructionWithValues(
+ &instruction);
+ QpackInstructionWithValuesPeer::set_name(&instruction_with_values, "");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("e0"));
- values.name = "foo";
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_name(&instruction_with_values, "foo");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("f294e7"));
- values.name = "bar";
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_name(&instruction_with_values, "bar");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("e3626172"));
}
@@ -115,17 +159,19 @@
const QpackInstruction instruction{QpackInstructionOpcode{0xf0, 0xf0},
{{QpackInstructionFieldType::kValue, 3}}};
- QpackInstructionEncoder::Values values;
- values.value = "";
- EncodeInstruction(&instruction, values);
+ auto instruction_with_values =
+ QpackInstructionWithValuesPeer::CreateQpackInstructionWithValues(
+ &instruction);
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("f0"));
- values.value = "foo";
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "foo");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("fa94e7"));
- values.value = "bar";
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "bar");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("f3626172"));
}
@@ -135,17 +181,19 @@
{QpackInstructionFieldType::kName, 2},
{QpackInstructionFieldType::kValue, 7}}};
- QpackInstructionEncoder::Values values;
- values.s_bit = false;
- values.name = "";
- values.value = "";
- EncodeInstruction(&instruction, values);
+ auto instruction_with_values =
+ QpackInstructionWithValuesPeer::CreateQpackInstructionWithValues(
+ &instruction);
+ QpackInstructionWithValuesPeer::set_s_bit(&instruction_with_values, false);
+ QpackInstructionWithValuesPeer::set_name(&instruction_with_values, "");
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("f000"));
- values.s_bit = true;
- values.name = "foo";
- values.value = "bar";
- EncodeInstruction(&instruction, values);
+ QpackInstructionWithValuesPeer::set_s_bit(&instruction_with_values, true);
+ QpackInstructionWithValuesPeer::set_name(&instruction_with_values, "foo");
+ QpackInstructionWithValuesPeer::set_value(&instruction_with_values, "bar");
+ EncodeInstruction(instruction_with_values);
EXPECT_TRUE(EncodedSegmentMatches("fe94e703626172"));
}