Rename ParseHeadersLength to ParseEncodedLength

In the upcoming version of the signed exchange format, the 3-byte big-endian
encoding would also be used to hold signature field length.
This CL renames the func so they are no longer "header" specific.

Bug: 803774
Change-Id: I15576ac789b9a95ae4e752cf305f1d73f05d72be
Reviewed-on: https://chromium-review.googlesource.com/1067277Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Tsuyoshi Horo <horo@chromium.org>
Reviewed-by: Kunihiko Sakamoto <ksakamoto@chromium.org>
Commit-Queue: Kouhei Ueno <kouhei@chromium.org>
Cr-Commit-Position: refs/heads/master@{#560239}

content/browser/web_package/signed_exchange_handler.cc

@@ -106,7 +106,7 @@ SignedExchangeHandler::SignedExchangeHandler(
   }
 
   // Triggering the read (asynchronously) for the encoded header length.
-  SetupBuffers(SignedExchangeHeader::kEncodedHeaderLengthInBytes);
+  SetupBuffers(SignedExchangeHeader::kEncodedLengthInBytes);
   base::SequencedTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::BindOnce(&SignedExchangeHandler::DoHeaderLoop,
                                 weak_factory_.GetWeakPtr()));
@@ -192,15 +192,15 @@ void SignedExchangeHandler::DidReadHeader(bool completed_syncly, int result) {
 
 bool SignedExchangeHandler::ParseHeadersLength() {
   TRACE_EVENT_BEGIN0(TRACE_DISABLED_BY_DEFAULT("loading"),
-                     "SignedExchangeHandler::ParseHeadersLength");
+                     "SignedExchangeHandler::ParseEncodedLength");
   DCHECK_EQ(state_, State::kReadingHeadersLength);
 
-  headers_length_ = SignedExchangeHeader::ParseHeadersLength(
+  headers_length_ = SignedExchangeHeader::ParseEncodedLength(
       base::make_span(reinterpret_cast<uint8_t*>(header_buf_->data()),
-                      SignedExchangeHeader::kEncodedHeaderLengthInBytes));
+                      SignedExchangeHeader::kEncodedLengthInBytes));
   if (headers_length_ == 0 || headers_length_ > kMaxHeadersCBORLength) {
     signed_exchange_utils::ReportErrorAndEndTraceEvent(
-        devtools_proxy_.get(), "SignedExchangeHandler::ParseHeadersLength",
+        devtools_proxy_.get(), "SignedExchangeHandler::ParseEncodedLength",
         base::StringPrintf("Invalid CBOR header length: %zu", headers_length_));
     return false;
   }
@@ -209,7 +209,7 @@ bool SignedExchangeHandler::ParseHeadersLength() {
   SetupBuffers(headers_length_);
   state_ = State::kReadingHeaders;
   TRACE_EVENT_END0(TRACE_DISABLED_BY_DEFAULT("loading"),
-                   "SignedExchangeHandler::ParseHeadersLength");
+                   "SignedExchangeHandler::ParseEncodedLength");
   return true;
 }
 

content/browser/web_package/signed_exchange_header.cc

@@ -259,12 +259,12 @@ bool ParseResponseMap(const cbor::CBORValue& value,
 
 }  // namespace
 
-constexpr size_t SignedExchangeHeader::kEncodedHeaderLengthInBytes;
+constexpr size_t SignedExchangeHeader::kEncodedLengthInBytes;
 
 // static
-size_t SignedExchangeHeader::ParseHeadersLength(
+size_t SignedExchangeHeader::ParseEncodedLength(
     base::span<const uint8_t> input) {
-  DCHECK_EQ(input.size(), SignedExchangeHeader::kEncodedHeaderLengthInBytes);
+  DCHECK_EQ(input.size(), SignedExchangeHeader::kEncodedLengthInBytes);
   return static_cast<size_t>(input[0]) << 16 |
          static_cast<size_t>(input[1]) << 8 | static_cast<size_t>(input[2]);
 }

content/browser/web_package/signed_exchange_header.h

@@ -28,12 +28,11 @@ class SignedExchangeDevToolsProxy;
 // https://wicg.github.io/webpackage/draft-yasskin-httpbis-origin-signed-exchanges-impl.html
 class CONTENT_EXPORT SignedExchangeHeader {
  public:
-  static constexpr size_t kEncodedHeaderLengthInBytes = 3;
-  // Parse big-endian encoded length of the following CBOR-encoded
-  // signed exchange header.
+  static constexpr size_t kEncodedLengthInBytes = 3;
+  // Parse encoded length of the variable-length field in the signed exchange.
   // Note: |input| must be pointing to a valid memory address that has at least
-  // |kEncodedHeaderLengthInBytes|.
-  static size_t ParseHeadersLength(base::span<const uint8_t> input);
+  // |kEncodedLengthInBytes|.
+  static size_t ParseEncodedLength(base::span<const uint8_t> input);
 
   using HeaderMap = std::map<std::string, std::string>;
 

content/browser/web_package/signed_exchange_header_unittest.cc

@@ -54,9 +54,9 @@ base::Optional<SignedExchangeHeader> GenerateHeaderAndParse(
 
 }  // namespace
 
-TEST(SignedExchangeHeaderTest, ParseHeaderLength) {
+TEST(SignedExchangeHeaderTest, ParseEncodedLength) {
   constexpr struct {
-    uint8_t bytes[SignedExchangeHeader::kEncodedHeaderLengthInBytes];
+    uint8_t bytes[SignedExchangeHeader::kEncodedLengthInBytes];
     size_t expected;
   } kTestCases[] = {
       {{0x00, 0x00, 0x01}, 1u}, {{0x01, 0xe2, 0x40}, 123456u},
@@ -65,7 +65,7 @@ TEST(SignedExchangeHeaderTest, ParseHeaderLength) {
   int test_element_index = 0;
   for (const auto& test_case : kTestCases) {
     SCOPED_TRACE(testing::Message() << "testing case " << test_element_index++);
-    EXPECT_EQ(SignedExchangeHeader::ParseHeadersLength(test_case.bytes),
+    EXPECT_EQ(SignedExchangeHeader::ParseEncodedLength(test_case.bytes),
               test_case.expected);
   }
 }
@@ -80,14 +80,14 @@ TEST(SignedExchangeHeaderTest, ParseGoldenFile) {
   ASSERT_TRUE(base::ReadFileToString(test_htxg_path, &contents));
   auto* contents_bytes = reinterpret_cast<const uint8_t*>(contents.data());
 
-  ASSERT_GT(contents.size(), SignedExchangeHeader::kEncodedHeaderLengthInBytes);
-  size_t header_size = SignedExchangeHeader::ParseHeadersLength(base::make_span(
-      contents_bytes, SignedExchangeHeader::kEncodedHeaderLengthInBytes));
+  ASSERT_GT(contents.size(), SignedExchangeHeader::kEncodedLengthInBytes);
+  size_t header_size = SignedExchangeHeader::ParseEncodedLength(base::make_span(
+      contents_bytes, SignedExchangeHeader::kEncodedLengthInBytes));
   ASSERT_GT(contents.size(),
-            SignedExchangeHeader::kEncodedHeaderLengthInBytes + header_size);
+            SignedExchangeHeader::kEncodedLengthInBytes + header_size);
 
   const auto cbor_bytes = base::make_span<const uint8_t>(
-      contents_bytes + SignedExchangeHeader::kEncodedHeaderLengthInBytes,
+      contents_bytes + SignedExchangeHeader::kEncodedLengthInBytes,
       header_size);
   const base::Optional<SignedExchangeHeader> header =
       SignedExchangeHeader::Parse(cbor_bytes, nullptr /* devtools_proxy */);

content/test/fuzzer/signed_exchange_header_fuzzer.cc

@@ -18,13 +18,13 @@ struct IcuEnvironment {
 IcuEnvironment* env = new IcuEnvironment();
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-  if (size < SignedExchangeHeader::kEncodedHeaderLengthInBytes)
+  if (size < SignedExchangeHeader::kEncodedLengthInBytes)
     return 0;
   auto encoded_length =
-      base::make_span(data, SignedExchangeHeader::kEncodedHeaderLengthInBytes);
-  size_t header_len = SignedExchangeHeader::ParseHeadersLength(encoded_length);
-  data += SignedExchangeHeader::kEncodedHeaderLengthInBytes;
-  size -= SignedExchangeHeader::kEncodedHeaderLengthInBytes;
+      base::make_span(data, SignedExchangeHeader::kEncodedLengthInBytes);
+  size_t header_len = SignedExchangeHeader::ParseEncodedLength(encoded_length);
+  data += SignedExchangeHeader::kEncodedLengthInBytes;
+  size -= SignedExchangeHeader::kEncodedLengthInBytes;
 
   // Copy the header into a separate buffer so that out-of-bounds access can be
   // detected.