Spelling

depstool/deps/parse_test.go

@@ -38,7 +38,7 @@ http_archive(
 		LastUpdated: "2022-05-18",
 	}
 	if !reflect.DeepEqual(*deps, expected) {
-		t.Errorf("Parsing returned incorret result, expected:\n  %v\n, got:\n  %v", expected, *deps)
+		t.Errorf("Parsing returned incorrect result, expected:\n  %v\n, got:\n  %v", expected, *deps)
 	}
 }
 

quiche/balsa/balsa_frame.h

@@ -226,7 +226,7 @@ class QUICHE_EXPORT BalsaFrame : public FramerInterface {
   }
 
   // If enabled, parse the available portion of headers even on a
-  // HEADERS_TOO_LONG error, so that that portion of headers is available to the
+  // HEADERS_TOO_LONG error, so that portion of headers is available to the
   // error handler. Generally results in the last header being truncated.
   void set_parse_truncated_headers_even_when_headers_too_long(bool set) {
     parse_truncated_headers_even_when_headers_too_long_ = set;

quiche/balsa/balsa_frame_test.cc

@@ -1709,7 +1709,7 @@ TEST_F(HTTPBalsaFrameTest,
       "trAnsfer-eNcoding:  chunked\r\n"
       "\r\n";
   std::string message_body =
-      "A            chunkjed extension  \r\n"
+      "A             chunked extension  \r\n"
       "01234567890            more crud including numbers 123123\r\n"
       "3f\n"
       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
@@ -1734,7 +1734,7 @@ TEST_F(HTTPBalsaFrameTest,
     EXPECT_CALL(visitor_mock_, HeaderDone());
     EXPECT_CALL(visitor_mock_, OnChunkLength(10));
     EXPECT_CALL(visitor_mock_,
-                OnChunkExtensionInput("            chunkjed extension  "));
+                OnChunkExtensionInput("             chunked extension  "));
     EXPECT_CALL(visitor_mock_, OnChunkLength(63));
     EXPECT_CALL(visitor_mock_, OnChunkExtensionInput(""));
     EXPECT_CALL(visitor_mock_, OnChunkLength(0));
@@ -1777,7 +1777,7 @@ TEST_P(HTTPBalsaFrameWithTrailersTest,
       "  \t includes a continuation\n"
       "\r\n";
   std::string message_body =
-      "A            chunkjed extension  \r\n"
+      "A             chunked extension  \r\n"
       "01234567890            more crud including numbers 123123\r\n"
       "3f\n"
       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
@@ -2192,7 +2192,7 @@ TEST_F(HTTPBalsaFrameTest,
       "trAnsfer-eNcoding:  chunked\r\n"
       "\r\n";
   std::string message_body =
-      "A            chunkjed extension  \r\n"
+      "A             chunked extension  \r\n"
       "01234567890            more crud including numbers 123123\r\n"
       "3f\n"
       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
@@ -2254,7 +2254,7 @@ TEST_P(HTTPBalsaFrameWithTrailersTest,
       "trAnsfer-eNcoding:  chunked\r\n"
       "\r\n";
   std::string message_body =
-      "A            chunkjed extension  \r\n"
+      "A             chunked extension  \r\n"
       "01234567890            more crud including numbers 123123\r\n"
       "3f\n"
       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
@@ -2331,7 +2331,7 @@ TEST_P(
       "trAnsfer-eNcoding:  chunked\r\n"
       "\r\n";
   std::string message_body =
-      "A            chunkjed extension  \r\n"
+      "A             chunked extension  \r\n"
       "01234567890            more crud including numbers 123123\r\n"
       "3f\n"
       "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
@@ -2414,7 +2414,7 @@ TEST(HTTPBalsaFrame,
         "trAnsfer-eNcoding:  chunked\r\n"
         "\r\n";
     std::string message_body =
-        "A            chunkjed extension  \r\n"
+        "A             chunked extension  \r\n"
         "01234567890            more crud including numbers 123123\r\n"
         "3f\n"
         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"
@@ -2510,7 +2510,7 @@ TEST(
         "trAnsfer-eNcoding:  chunked\r\n"
         "\r\n";
     std::string message_body =
-        "A            chunkjed extension  \r\n"
+        "A             chunked extension  \r\n"
         "01234567890            more crud including numbers 123123\r\n"
         "3f\n"
         "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\n"

quiche/balsa/balsa_headers.cc

@@ -196,7 +196,7 @@ void BalsaHeaders::ParseTokenList(absl::string_view header_value,
     // found. marked.
     const char* nws = start;
 
-    // search for next whitspace or separator char.
+    // search for next whitespace or separator char.
     while (*start != ',' && static_cast<unsigned char>(*start) > ' ') {
       ++start;
       if (start == end) {
@@ -625,7 +625,7 @@ void BalsaHeaders::RemoveAllOfHeaderInList(const HeaderTokenList& keys) {
   // This extra copy sacrifices some performance to prevent the possible
   // mistakes that the caller does not lower case the headers in keys.
   // Better performance can be achieved by asking caller to lower case
-  // the keys and RemoveAllOfheaderInlist just does lookup.
+  // the keys and RemoveAllOfheaderInList just does lookup.
   absl::flat_hash_set<std::string> lowercase_keys;
   for (const auto& key : keys) {
     MaybeClearSpecialHeaderValues(key);
@@ -1102,7 +1102,7 @@ void BalsaHeaders::RemoveLastTokenFromHeaderValue(absl::string_view key) {
       GetHeaderLinesIterator(key, header_lines_.begin());
   if (it == header_lines_.end()) {
     QUICHE_DLOG(WARNING)
-        << "Attempting to remove last token from a non-existent "
+        << "Attempting to remove last token from a nonexistent "
         << "header \"" << key << "\"";
     return;
   }

quiche/balsa/balsa_headers.h

@@ -890,7 +890,7 @@ class QUICHE_EXPORT BalsaHeaders : public HeaderApi {
 
   absl::string_view response_code() const override {
     // Note: There is no difference between request_uri() and response_code().
-    // They both could be called GetSecondtTokenFromFirstline(), but, as noted
+    // They both could be called GetSecondTokenFromFirstline(), but, as noted
     // in an earlier comment, that wouldn't be as descriptive.
     return request_uri();
   }

quiche/balsa/balsa_headers_test.cc

@@ -2450,7 +2450,7 @@ TEST(BalsaHeaders,
   SCOPED_TRACE(
       "This test tests the codepath where the new firstline is"
       " too large to fit within the space used by the original"
-      " firstline, but large enuogh to space in the free space"
+      " firstline, but large enough to space in the free space"
       " available in both firstline plus the space made available"
       " with deleted header lines (specifically, the first one");
   BalsaHeaders headers = CreateHTTPHeaders(
@@ -2523,7 +2523,7 @@ TEST(BalsaHeaders, TestSettingMissingFirstlineElementsAfterBalsaHeadersParsed) {
   }
 }
 
-// Here we exersize the codepaths involved in setting a new firstine when the
+// Here we exercise the codepaths involved in setting a new firstline when the
 // previously set firstline is stored in the 'additional_data_stream_'
 // variable, and the new firstline is larger than the previously set firstline.
 TEST(BalsaHeaders,
@@ -2549,7 +2549,7 @@ TEST(BalsaHeaders,
               StrEq("HTTP/1.10 2000 REALLY don't need a reason"));
 }
 
-// Here we exersize the codepaths involved in setting a new firstine when the
+// Here we exercise the codepaths involved in setting a new firstline when the
 // previously set firstline is stored in the 'additional_data_stream_'
 // variable, and the new firstline is smaller than the previously set firstline.
 TEST(BalsaHeaders,
@@ -3041,7 +3041,7 @@ TEST(BalsaHeaders, TestAppendToHeaderWithCommaAndSpace) {
 }
 
 TEST(BalsaHeaders, TestInitialAppendWithCommaAndSpace) {
-  // Test that AppendToHeadeWithCommaAndSpace works properly when the
+  // Test that AppendToHeaderWithCommaAndSpace works properly when the
   // header did not already exist.
   BalsaHeaders headers;
   headers.AppendToHeaderWithCommaAndSpace("foo", "foo_value");
@@ -3051,7 +3051,7 @@ TEST(BalsaHeaders, TestInitialAppendWithCommaAndSpace) {
 }
 
 TEST(BalsaHeaders, TestAppendWithCommaAndSpaceAndRemove) {
-  // Test that AppendToHeadeWithCommaAndSpace works properly with removing.
+  // Test that AppendToHeaderWithCommaAndSpace works properly with removing.
   BalsaHeaders headers;
   headers.AppendToHeaderWithCommaAndSpace("foo", "foo_value");
   EXPECT_THAT(headers.GetHeader("foo"), StrEq("foo_value"));

quiche/blind_sign_auth/proto/auth_and_sign.proto

@@ -80,6 +80,6 @@ message AuthAndSignResponse {
   // users in the format of "${Region}.${timestamp}.${signature}".
   string region_token_and_signature = 6;
 
-  // The APN type bridge-proxy use to deside which APN to use for connecting.
+  // The APN type bridge-proxy use to decide which APN to use for connecting.
   string apn_type = 7;
 }

quiche/common/platform/api/quiche_default_proof_providers.h

@@ -23,7 +23,7 @@ inline std::unique_ptr<quic::ProofVerifier> CreateDefaultProofVerifier(
 }
 
 // Provides a default proof source for CLI-based tools.  The actual certificates
-// used in the proof source should be confifgurable via command-line flags.
+// used in the proof source should be configurable via command-line flags.
 inline std::unique_ptr<quic::ProofSource> CreateDefaultProofSource() {
   return CreateDefaultProofSourceImpl();
 }

quiche/common/platform/api/quiche_server_stats.h

@@ -70,7 +70,7 @@ namespace quiche {
 
 // Sample usage:
 //   QUICHE_SERVER_SERVER_HISTOGRAM_CUSTOM_COUNTS("My.Histogram", 1, 100000000,
-//   100, "Counters of hitting certian code.");
+//   100, "Counters of hitting certain code.");
 
 #define QUICHE_SERVER_HISTOGRAM_COUNTS(name, sample, min, max, bucket_count, \
                                        docstring)                            \

quiche/common/platform/api/quiche_url_utils.h

@@ -18,7 +18,7 @@ namespace quiche {
 
 // Produces concrete URLs in |target| from templated ones in |uri_template|.
 // Parameters are URL-encoded. Collects the names of any expanded variables in
-// |vars_found|. Returns true if the template was parseable, false if it was
+// |vars_found|. Returns true if the template was parsable, false if it was
 // malformed.
 inline bool ExpandURITemplate(
     const std::string& uri_template,

quiche/common/platform/default/quiche_platform_impl/quiche_url_utils_impl.h

@@ -18,7 +18,7 @@ namespace quiche {
 // Produces concrete URLs in |target| from templated ones in |uri_template|.
 // Parameters are URL-encoded. Collects the names of any expanded variables in
 // |vars_found|. Supports level 1 templates as specified in RFC 6570. Returns
-// true if the template was parseable, false if it was malformed.
+// true if the template was parsable, false if it was malformed.
 QUICHE_EXPORT bool ExpandURITemplateImpl(
     const std::string& uri_template,
     const absl::flat_hash_map<std::string, std::string>& parameters,

quiche/common/quiche_circular_deque.h

@@ -29,11 +29,11 @@ namespace quiche {
 // all elements. At any point in time, either
 // a) All elements are placed in a contiguous portion of this buffer, like a
 //    c-array, or
-// b) Elements are phycially divided into two parts: the first part occupies the
+// b) Elements are physically divided into two parts: the first part occupies the
 //    end of the buffer and the second part occupies the beginning of the
 //    buffer.
 //
-// Currently, elements can only be pushed or poped from either ends, it can't be
+// Currently, elements can only be pushed or popped from either ends, it can't be
 // inserted or erased in the middle.
 //
 // TODO(wub): Make memory grow/shrink strategies customizable.

quiche/common/quiche_data_writer.cc

@@ -214,7 +214,7 @@ bool QuicheDataWriter::WriteVarInt62(uint64_t value) {
     }
     return false;
   }
-  // Can not encode, high 2 bits not 0
+  // Cannot encode, high 2 bits not 0
   return false;
 }
 

quiche/common/quiche_ip_address_family.h

@@ -9,7 +9,7 @@
 
 namespace quiche {
 
-// IP address family type used in QUIC. This hides platform dependant IP address
+// IP address family type used in QUIC. This hides platform dependent IP address
 // family types.
 enum class IpAddressFamily {
   IP_V4,

quiche/common/structured_headers_generated_test.cc

@@ -64,7 +64,7 @@ const struct ParameterizedItemTestCase {
      2,
      {{Item("", Item::kByteSequenceType), {}}},
      nullptr},
-    {"bad paddding",
+    {"bad padding",
      ":aGVsbG8:",
      9,
      {{Item("hello", Item::kByteSequenceType), {}}},

quiche/common/structured_headers_test.cc

@@ -98,7 +98,7 @@ const ItemTestCase sh09_item_test_cases[] = {
     {"basic binary", "*aGVsbG8=*", Item("hello", Item::kByteSequenceType),
      nullptr},
     {"empty binary", "**", Item("", Item::kByteSequenceType), nullptr},
-    {"bad paddding", "*aGVsbG8*", Item("hello", Item::kByteSequenceType),
+    {"bad padding", "*aGVsbG8*", Item("hello", Item::kByteSequenceType),
      "*aGVsbG8=*"},
     {"bad end delimiter", "*aGVsbG8=", absl::nullopt, nullptr},
     {"extra whitespace", "*aGVsb G8=*", absl::nullopt, nullptr},
@@ -581,8 +581,8 @@ TEST(StructuredHeaderTest, UnserializableDecimals) {
 
 // These values cannot be directly parsed from headers, but are valid doubles
 // which can be serialized as sh-floats (though rounding is expected.)
-TEST(StructuredHeaderTest, SerializeUnparseableDecimals) {
-  struct UnparseableDecimal {
+TEST(StructuredHeaderTest, SerializeUnparsableDecimals) {
+  struct UnparsableDecimal {
     const char* name;
     double value;
     const char* canonical;

quiche/http2/adapter/adapter_impl_comparison_test.cc

@@ -35,7 +35,7 @@ TEST(AdapterImplComparisonTest, ClientHandlesFrames) {
             oghttp2_visitor.GetEventSequence());
 
   // TODO(b/181586191): Consider consistent behavior for delivering events on
-  // non-existent streams between nghttp2_adapter and oghttp2_adapter.
+  // nonexistent streams between nghttp2_adapter and oghttp2_adapter.
 }
 
 TEST(AdapterImplComparisonTest, SubmitWindowUpdateBumpsWindow) {

quiche/http2/adapter/header_validator_test.cc

@@ -39,7 +39,7 @@ TEST(HeaderValidatorTest, ExceedsMaxSize) {
   EXPECT_EQ(HeaderValidator::HEADER_OK, status);
   status = v.ValidateSingleHeader(
       "name2",
-      "Antidisestablishmentariansism is supercalifragilisticexpialodocious.");
+      "Antidisestablishmentariansism is supercalifragilisticexpealidocious.");
   EXPECT_EQ(HeaderValidator::HEADER_FIELD_TOO_LONG, status);
 }
 
@@ -432,7 +432,7 @@ TEST(HeaderValidatorTest, WebsocketPseudoHeaders) {
   }
   EXPECT_EQ(HeaderValidator::HEADER_OK,
             v.ValidateSingleHeader(":protocol", "websocket"));
-  // After allowing the method, `:protocol` is acepted for CONNECT requests.
+  // After allowing the method, `:protocol` is accepted for CONNECT requests.
   EXPECT_TRUE(v.FinishHeaderBlock(HeaderType::REQUEST));
 }
 

quiche/http2/adapter/mock_http2_visitor.h

@@ -54,7 +54,7 @@ class QUICHE_NO_EXPORT MockHttp2Visitor : public Http2VisitorInterface {
               (override));
 
   MOCK_METHOD(bool, OnDataPaddingLength,
-              (Http2StreamId strema_id, size_t padding_length), (override));
+              (Http2StreamId stream_id, size_t padding_length), (override));
 
   MOCK_METHOD(bool, OnBeginDataForStream,
               (Http2StreamId stream_id, size_t payload_length), (override));

quiche/http2/adapter/nghttp2_adapter_test.cc

@@ -247,7 +247,7 @@ TEST(NgHttp2AdapterTest, ClientHandlesFrames) {
   // Should be 3, but this method only works for server adapters.
   EXPECT_EQ(0, adapter->GetHighestReceivedStreamId());
 
-  // Even though the client recieved a GOAWAY, streams 1 and 5 are still active.
+  // Even though the client received a GOAWAY, streams 1 and 5 are still active.
   EXPECT_TRUE(adapter->want_read());
 
   EXPECT_CALL(visitor, OnFrameHeader(1, 0, DATA, 1));

quiche/http2/adapter/nghttp2_session_test.cc

@@ -180,7 +180,7 @@ TEST_F(NgHttp2SessionTest, ClientHandlesFrames) {
   const int64_t stream_result = session.ProcessBytes(stream_frames);
   EXPECT_EQ(stream_frames.size(), stream_result);
 
-  // Even though the client recieved a GOAWAY, streams 1 and 5 are still active.
+  // Even though the client received a GOAWAY, streams 1 and 5 are still active.
   EXPECT_TRUE(session.want_read());
 
   EXPECT_CALL(visitor_, OnFrameHeader(1, 0, DATA, 1));

quiche/http2/adapter/noop_header_validator_test.cc

@@ -40,7 +40,7 @@ TEST(NoopHeaderValidatorTest, ExceedsMaxSize) {
   EXPECT_EQ(NoopHeaderValidator::HEADER_OK, status);
   status = v.ValidateSingleHeader(
       "name2",
-      "Antidisestablishmentariansism is supercalifragilisticexpialodocious.");
+      "Antidisestablishmentariansism is supercalifragilisticexpealidocious.");
   EXPECT_EQ(NoopHeaderValidator::HEADER_OK, status);
 }
 
@@ -227,7 +227,7 @@ TEST(NoopHeaderValidatorTest, WebsocketPseudoHeaders) {
   }
   EXPECT_EQ(NoopHeaderValidator::HEADER_OK,
             v.ValidateSingleHeader(":protocol", "websocket"));
-  // After allowing the method, `:protocol` is acepted for CONNECT requests.
+  // After allowing the method, `:protocol` is accepted for CONNECT requests.
   EXPECT_TRUE(v.FinishHeaderBlock(HeaderType::REQUEST));
 }
 

quiche/http2/adapter/oghttp2_session.cc

@@ -36,7 +36,7 @@ const int kSendError = -902;
 
 constexpr absl::string_view kHeadValue = "HEAD";
 
-// TODO(birenroy): Consider incorporating spdy::FlagsSerializionVisitor here.
+// TODO(birenroy): Consider incorporating spdy::FlagsSerializationVisitor here.
 class FrameAttributeCollector : public spdy::SpdyFrameVisitor {
  public:
   FrameAttributeCollector() = default;
@@ -1158,7 +1158,7 @@ void OgHttp2Session::OnStreamPadLength(spdy::SpdyStreamId stream_id,
 void OgHttp2Session::OnStreamPadding(spdy::SpdyStreamId /*stream_id*/, size_t
                                      /*len*/) {
   // Flow control was accounted for in OnStreamPadLength().
-  // TODO(181586191): Pass padding to the visitor?
+  // TODO(b/181586191): Pass padding to the visitor?
 }
 
 spdy::SpdyHeadersHandlerInterface* OgHttp2Session::OnHeaderFrameStart(
@@ -1473,7 +1473,7 @@ void OgHttp2Session::OnWindowUpdate(spdy::SpdyStreamId stream_id,
         LatchErrorAndNotify(Http2ErrorCode::PROTOCOL_ERROR,
                             ConnectionError::kWrongFrameSequence);
       }
-      // Do not inform the visitor of a WINDOW_UPDATE for a non-existent stream.
+      // Do not inform the visitor of a WINDOW_UPDATE for a nonexistent stream.
       return;
     } else {
       if (streams_reset_.contains(stream_id)) {

quiche/http2/adapter/oghttp2_session.h

@@ -353,7 +353,7 @@ class QUICHE_EXPORT OgHttp2Session : public Http2Session,
   };
   using ProcessBytesResult = absl::variant<int64_t, ProcessBytesError>;
 
-  // Attempts to process `bytes` and returns the number of bytes proccessed on
+  // Attempts to process `bytes` and returns the number of bytes processed on
   // success or the processing error on failure.
   ProcessBytesResult ProcessBytesImpl(absl::string_view bytes);