Rename SpdyHeaderBlock to Http2HeaderBlock, with a using alias.
The goal is to rename SpdyHeaderBlock to Http2HeaderBlock, but performing that
rename globally in one CL would be rather large (cl/336384859). Instead, this
CL performs the rename just for the library and adds a using alias to allow the
global rename to be performed piecemeal. Thanks to ++birenroy@ for the idea!
As part of the alias addition, this CL also removes some forward declarations
of SpdyHeaderBlock in favor of #include-ing the corresponding header file. This
substitution is needed to prevent compilation errors like:
./third_party/quic/tools/quic_simple_server_backend.h:12:7: error: definition of type 'SpdyHeaderBlock' conflicts with type alias of the same name
class SpdyHeaderBlock;
^
./third_party/spdy/core/spdy_header_block.h:294:7: note: 'SpdyHeaderBlock' declared here
using SpdyHeaderBlock = Http2HeaderBlock;
PiperOrigin-RevId: 338091517
Change-Id: Ib1db825a7e7b6775f9da6b377fdd3321a6d204ce
diff --git a/spdy/core/spdy_header_block_test.cc b/spdy/core/spdy_header_block_test.cc
index a8dbe01..9fd7b68 100644
--- a/spdy/core/spdy_header_block_test.cc
+++ b/spdy/core/spdy_header_block_test.cc
@@ -17,7 +17,7 @@
class ValueProxyPeer {
public:
- static absl::string_view key(SpdyHeaderBlock::ValueProxy* p) {
+ static absl::string_view key(Http2HeaderBlock::ValueProxy* p) {
return p->key_;
}
};
@@ -27,9 +27,9 @@
return std::make_pair(k, v);
}
-// This test verifies that SpdyHeaderBlock behaves correctly when empty.
-TEST(SpdyHeaderBlockTest, EmptyBlock) {
- SpdyHeaderBlock block;
+// This test verifies that Http2HeaderBlock behaves correctly when empty.
+TEST(Http2HeaderBlockTest, EmptyBlock) {
+ Http2HeaderBlock block;
EXPECT_TRUE(block.empty());
EXPECT_EQ(0u, block.size());
EXPECT_EQ(block.end(), block.find("foo"));
@@ -39,8 +39,8 @@
block.erase("bar");
}
-TEST(SpdyHeaderBlockTest, KeyMemoryReclaimedOnLookup) {
- SpdyHeaderBlock block;
+TEST(Http2HeaderBlockTest, KeyMemoryReclaimedOnLookup) {
+ Http2HeaderBlock block;
absl::string_view copied_key1;
{
auto proxy1 = block["some key name"];
@@ -62,7 +62,7 @@
block["some other key name"] = "some value";
}
// Nothing should blow up when proxy1 is destructed, and we should be able to
- // modify and access the SpdyHeaderBlock.
+ // modify and access the Http2HeaderBlock.
block["key"] = "value";
EXPECT_EQ("value", block["key"]);
EXPECT_EQ("some value", block["some other key name"]);
@@ -70,8 +70,8 @@
}
// This test verifies that headers can be set in a variety of ways.
-TEST(SpdyHeaderBlockTest, AddHeaders) {
- SpdyHeaderBlock block;
+TEST(Http2HeaderBlockTest, AddHeaders) {
+ Http2HeaderBlock block;
block["foo"] = std::string(300, 'x');
block["bar"] = "baz";
block["qux"] = "qux1";
@@ -89,29 +89,29 @@
EXPECT_EQ(block.end(), block.find("key"));
}
-// This test verifies that SpdyHeaderBlock can be copied using Clone().
-TEST(SpdyHeaderBlockTest, CopyBlocks) {
- SpdyHeaderBlock block1;
+// This test verifies that Http2HeaderBlock can be copied using Clone().
+TEST(Http2HeaderBlockTest, CopyBlocks) {
+ Http2HeaderBlock block1;
block1["foo"] = std::string(300, 'x');
block1["bar"] = "baz";
block1.insert(std::make_pair("qux", "qux1"));
- SpdyHeaderBlock block2 = block1.Clone();
- SpdyHeaderBlock block3(block1.Clone());
+ Http2HeaderBlock block2 = block1.Clone();
+ Http2HeaderBlock block3(block1.Clone());
EXPECT_EQ(block1, block2);
EXPECT_EQ(block1, block3);
}
-TEST(SpdyHeaderBlockTest, Equality) {
+TEST(Http2HeaderBlockTest, Equality) {
// Test equality and inequality operators.
- SpdyHeaderBlock block1;
+ Http2HeaderBlock block1;
block1["foo"] = "bar";
- SpdyHeaderBlock block2;
+ Http2HeaderBlock block2;
block2["foo"] = "bar";
- SpdyHeaderBlock block3;
+ Http2HeaderBlock block3;
block3["baz"] = "qux";
EXPECT_EQ(block1, block2);
@@ -121,28 +121,28 @@
EXPECT_NE(block1, block2);
}
-SpdyHeaderBlock ReturnTestHeaderBlock() {
- SpdyHeaderBlock block;
+Http2HeaderBlock ReturnTestHeaderBlock() {
+ Http2HeaderBlock block;
block["foo"] = "bar";
block.insert(std::make_pair("foo2", "baz"));
return block;
}
// Test that certain methods do not crash on moved-from instances.
-TEST(SpdyHeaderBlockTest, MovedFromIsValid) {
- SpdyHeaderBlock block1;
+TEST(Http2HeaderBlockTest, MovedFromIsValid) {
+ Http2HeaderBlock block1;
block1["foo"] = "bar";
- SpdyHeaderBlock block2(std::move(block1));
+ Http2HeaderBlock block2(std::move(block1));
EXPECT_THAT(block2, ElementsAre(Pair("foo", "bar")));
block1["baz"] = "qux"; // NOLINT testing post-move behavior
- SpdyHeaderBlock block3(std::move(block1));
+ Http2HeaderBlock block3(std::move(block1));
block1["foo"] = "bar"; // NOLINT testing post-move behavior
- SpdyHeaderBlock block4(std::move(block1));
+ Http2HeaderBlock block4(std::move(block1));
block1.clear(); // NOLINT testing post-move behavior
EXPECT_TRUE(block1.empty());
@@ -150,7 +150,7 @@
block1["foo"] = "bar";
EXPECT_THAT(block1, ElementsAre(Pair("foo", "bar")));
- SpdyHeaderBlock block5 = ReturnTestHeaderBlock();
+ Http2HeaderBlock block5 = ReturnTestHeaderBlock();
block5.AppendValueOrAddHeader("foo", "bar2");
EXPECT_THAT(block5, ElementsAre(Pair("foo", std::string("bar\0bar2", 8)),
Pair("foo2", "baz")));
@@ -158,8 +158,8 @@
// This test verifies that headers can be appended to no matter how they were
// added originally.
-TEST(SpdyHeaderBlockTest, AppendHeaders) {
- SpdyHeaderBlock block;
+TEST(Http2HeaderBlockTest, AppendHeaders) {
+ Http2HeaderBlock block;
block["foo"] = "foo";
block.AppendValueOrAddHeader("foo", "bar");
EXPECT_EQ(Pair("foo", std::string("foo\0bar", 7)), *block.find("foo"));
@@ -192,8 +192,8 @@
EXPECT_EQ("singleton", block["h4"]);
}
-TEST(SpdyHeaderBlockTest, CompareValueToStringPiece) {
- SpdyHeaderBlock block;
+TEST(Http2HeaderBlockTest, CompareValueToStringPiece) {
+ Http2HeaderBlock block;
block["foo"] = "foo";
block.AppendValueOrAddHeader("foo", "bar");
const auto& val = block["foo"];
@@ -213,10 +213,10 @@
EXPECT_FALSE(val2 == absl::string_view(""));
}
-// This test demonstrates that the SpdyHeaderBlock data structure does not place
-// any limitations on the characters present in the header names.
-TEST(SpdyHeaderBlockTest, UpperCaseNames) {
- SpdyHeaderBlock block;
+// This test demonstrates that the Http2HeaderBlock data structure does not
+// place any limitations on the characters present in the header names.
+TEST(Http2HeaderBlockTest, UpperCaseNames) {
+ Http2HeaderBlock block;
block["Foo"] = "foo";
block.AppendValueOrAddHeader("Foo", "bar");
EXPECT_NE(block.end(), block.find("foo"));
@@ -230,7 +230,7 @@
}
namespace {
-size_t SpdyHeaderBlockSize(const SpdyHeaderBlock& block) {
+size_t Http2HeaderBlockSize(const Http2HeaderBlock& block) {
size_t size = 0;
for (const auto& pair : block) {
size += pair.first.size() + pair.second.size();
@@ -239,38 +239,38 @@
}
} // namespace
-// Tests SpdyHeaderBlock SizeEstimate().
-TEST(SpdyHeaderBlockTest, TotalBytesUsed) {
- SpdyHeaderBlock block;
+// Tests Http2HeaderBlock SizeEstimate().
+TEST(Http2HeaderBlockTest, TotalBytesUsed) {
+ Http2HeaderBlock block;
const size_t value_size = 300;
block["foo"] = std::string(value_size, 'x');
- EXPECT_EQ(block.TotalBytesUsed(), SpdyHeaderBlockSize(block));
+ EXPECT_EQ(block.TotalBytesUsed(), Http2HeaderBlockSize(block));
block.insert(std::make_pair("key", std::string(value_size, 'x')));
- EXPECT_EQ(block.TotalBytesUsed(), SpdyHeaderBlockSize(block));
+ EXPECT_EQ(block.TotalBytesUsed(), Http2HeaderBlockSize(block));
block.AppendValueOrAddHeader("abc", std::string(value_size, 'x'));
- EXPECT_EQ(block.TotalBytesUsed(), SpdyHeaderBlockSize(block));
+ EXPECT_EQ(block.TotalBytesUsed(), Http2HeaderBlockSize(block));
// Replace value for existing key.
block["foo"] = std::string(value_size, 'x');
- EXPECT_EQ(block.TotalBytesUsed(), SpdyHeaderBlockSize(block));
+ EXPECT_EQ(block.TotalBytesUsed(), Http2HeaderBlockSize(block));
block.insert(std::make_pair("key", std::string(value_size, 'x')));
- EXPECT_EQ(block.TotalBytesUsed(), SpdyHeaderBlockSize(block));
+ EXPECT_EQ(block.TotalBytesUsed(), Http2HeaderBlockSize(block));
// Add value for existing key.
block.AppendValueOrAddHeader("abc", std::string(value_size, 'x'));
- EXPECT_EQ(block.TotalBytesUsed(), SpdyHeaderBlockSize(block));
+ EXPECT_EQ(block.TotalBytesUsed(), Http2HeaderBlockSize(block));
- // Copies/clones SpdyHeaderBlock.
+ // Copies/clones Http2HeaderBlock.
size_t block_size = block.TotalBytesUsed();
- SpdyHeaderBlock block_copy = std::move(block);
+ Http2HeaderBlock block_copy = std::move(block);
EXPECT_EQ(block_size, block_copy.TotalBytesUsed());
// Erases key.
block_copy.erase("foo");
- EXPECT_EQ(block_copy.TotalBytesUsed(), SpdyHeaderBlockSize(block_copy));
+ EXPECT_EQ(block_copy.TotalBytesUsed(), Http2HeaderBlockSize(block_copy));
block_copy.erase("key");
- EXPECT_EQ(block_copy.TotalBytesUsed(), SpdyHeaderBlockSize(block_copy));
+ EXPECT_EQ(block_copy.TotalBytesUsed(), Http2HeaderBlockSize(block_copy));
block_copy.erase("abc");
- EXPECT_EQ(block_copy.TotalBytesUsed(), SpdyHeaderBlockSize(block_copy));
+ EXPECT_EQ(block_copy.TotalBytesUsed(), Http2HeaderBlockSize(block_copy));
}
} // namespace test
