http: more 1xx renames

envoy/http/filter.h

@@ -466,7 +466,7 @@ class StreamDecoderFilterCallbacks : public virtual StreamFilterCallbacks {
    * Returns the headers provided to encode1xxHeaders. Returns absl::nullopt if
    * no headers have been provided yet.
    */
-  virtual ResponseHeaderMapOptRef continueHeaders() const PURE;
+  virtual ResponseHeaderMapOptRef informationalHeaders() const PURE;
 
   /**
    * Called with headers to be encoded, optionally indicating end of stream.

source/common/http/async_client_impl.h

@@ -378,7 +378,7 @@ class AsyncStreamImpl : public AsyncClient::Stream,
   }
   // The async client won't pause if sending 1xx headers so simply swallow any.
   void encode1xxHeaders(ResponseHeaderMapPtr&&) override {}
-  ResponseHeaderMapOptRef continueHeaders() const override { NOT_IMPLEMENTED_GCOVR_EXCL_LINE; }
+  ResponseHeaderMapOptRef informationalHeaders() const override { NOT_IMPLEMENTED_GCOVR_EXCL_LINE; }
   void encodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream,
                      absl::string_view details) override;
   ResponseHeaderMapOptRef responseHeaders() const override { NOT_IMPLEMENTED_GCOVR_EXCL_LINE; }

source/common/http/conn_manager_impl.h

@@ -222,9 +222,9 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
       ASSERT(!request_trailers_);
       request_trailers_ = std::move(request_trailers);
     }
-    void setContinueHeaders(Http::ResponseHeaderMapPtr&& continue_headers) override {
-      ASSERT(!continue_headers_);
-      continue_headers_ = std::move(continue_headers);
+    void setInformationalHeaders(Http::ResponseHeaderMapPtr&& informational_headers) override {
+      ASSERT(!informational_headers_);
+      informational_headers_ = std::move(informational_headers);
     }
     void setResponseHeaders(Http::ResponseHeaderMapPtr&& response_headers) override {
       // We'll overwrite the headers in the case where we fail the stream after upstream headers
@@ -242,8 +242,8 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
     Http::RequestTrailerMapOptRef requestTrailers() override {
       return makeOptRefFromPtr(request_trailers_.get());
     }
-    Http::ResponseHeaderMapOptRef continueHeaders() override {
-      return makeOptRefFromPtr(continue_headers_.get());
+    Http::ResponseHeaderMapOptRef informationalHeaders() override {
+      return makeOptRefFromPtr(informational_headers_.get());
     }
     Http::ResponseHeaderMapOptRef responseHeaders() override {
       return makeOptRefFromPtr(response_headers_.get());
@@ -353,7 +353,7 @@ class ConnectionManagerImpl : Logger::Loggable<Logger::Id::http>,
     RequestHeaderMapPtr request_headers_;
     RequestTrailerMapPtr request_trailers_;
 
-    ResponseHeaderMapPtr continue_headers_;
+    ResponseHeaderMapPtr informational_headers_;
     ResponseHeaderMapPtr response_headers_;
     ResponseTrailerMapPtr response_trailers_;
 

source/common/http/filter_manager.cc

@@ -395,13 +395,13 @@ void ActiveStreamDecoderFilter::encode1xxHeaders(ResponseHeaderMapPtr&& headers)
   // here. This avoids the potential situation where Envoy strips Expect: 100-Continue and sends a
   // 100-Continue, then proxies a duplicate 100 Continue from upstream.
   if (parent_.proxy_100_continue_) {
-    parent_.filter_manager_callbacks_.setContinueHeaders(std::move(headers));
-    parent_.encode1xxHeaders(nullptr, *parent_.filter_manager_callbacks_.continueHeaders());
+    parent_.filter_manager_callbacks_.setInformationalHeaders(std::move(headers));
+    parent_.encode1xxHeaders(nullptr, *parent_.filter_manager_callbacks_.informationalHeaders());
   }
 }
 
-ResponseHeaderMapOptRef ActiveStreamDecoderFilter::continueHeaders() const {
-  return parent_.filter_manager_callbacks_.continueHeaders();
+ResponseHeaderMapOptRef ActiveStreamDecoderFilter::informationalHeaders() const {
+  return parent_.filter_manager_callbacks_.informationalHeaders();
 }
 
 void ActiveStreamDecoderFilter::encodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream,
@@ -1528,7 +1528,7 @@ bool ActiveStreamEncoderFilter::has1xxheaders() {
   return parent_.state_.has_1xx_headers_ && !continued_1xx_headers_;
 }
 void ActiveStreamEncoderFilter::do1xxHeaders() {
-  parent_.encode1xxHeaders(this, *parent_.filter_manager_callbacks_.continueHeaders());
+  parent_.encode1xxHeaders(this, *parent_.filter_manager_callbacks_.informationalHeaders());
 }
 void ActiveStreamEncoderFilter::doHeaders(bool end_stream) {
   parent_.encodeHeaders(this, *parent_.filter_manager_callbacks_.responseHeaders(), end_stream);

source/common/http/filter_manager.h

@@ -260,7 +260,7 @@ struct ActiveStreamDecoderFilter : public ActiveStreamFilterBase,
                       const absl::optional<Grpc::Status::GrpcStatus> grpc_status,
                       absl::string_view details) override;
   void encode1xxHeaders(ResponseHeaderMapPtr&& headers) override;
-  ResponseHeaderMapOptRef continueHeaders() const override;
+  ResponseHeaderMapOptRef informationalHeaders() const override;
   void encodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream,
                      absl::string_view details) override;
   ResponseHeaderMapOptRef responseHeaders() const override;
@@ -407,10 +407,10 @@ class FilterManagerCallbacks {
   virtual void setRequestTrailers(RequestTrailerMapPtr&& request_trailers) PURE;
 
   /**
-   * Passes ownership of received continue headers to the parent. This may be called multiple times
-   * in the case of multiple upstream calls.
+   * Passes ownership of received informational headers to the parent. This may be called multiple
+   * times in the case of multiple upstream calls.
    */
-  virtual void setContinueHeaders(ResponseHeaderMapPtr&& response_headers) PURE;
+  virtual void setInformationalHeaders(ResponseHeaderMapPtr&& response_headers) PURE;
 
   /**
    * Passes ownership of received response headers to the parent. This may be called multiple times
@@ -443,9 +443,9 @@ class FilterManagerCallbacks {
   virtual RequestTrailerMapOptRef requestTrailers() PURE;
 
   /**
-   * Retrieves a pointer to the continue headers set via the call to setContinueHeaders.
+   * Retrieves a pointer to the continue headers set via the call to setInformationalHeaders.
    */
-  virtual ResponseHeaderMapOptRef continueHeaders() PURE;
+  virtual ResponseHeaderMapOptRef informationalHeaders() PURE;
 
   /**
    * Retrieves a pointer to the response headers set via the last call to setResponseHeaders.

test/integration/http_integration.cc

@@ -1006,9 +1006,9 @@ void HttpIntegrationTest::testEnvoyHandling1xx(bool additional_continue_from_ups
 
   ASSERT_TRUE(response->waitForEndStream());
   ASSERT_TRUE(response->complete());
-  ASSERT(response->continueHeaders() != nullptr);
-  EXPECT_EQ("100", response->continueHeaders()->getStatusValue());
-  EXPECT_EQ(nullptr, response->continueHeaders()->Via());
+  ASSERT(response->informationalHeaders() != nullptr);
+  EXPECT_EQ("100", response->informationalHeaders()->getStatusValue());
+  EXPECT_EQ(nullptr, response->informationalHeaders()->Via());
   EXPECT_EQ("200", response->headers().getStatusValue());
   if (via.empty()) {
     EXPECT_EQ(nullptr, response->headers().Via());
@@ -1073,8 +1073,8 @@ void HttpIntegrationTest::testEnvoyProxying1xx(bool continue_before_upstream_com
   upstream_request_->encodeHeaders(default_response_headers_, true);
   ASSERT_TRUE(response->waitForEndStream());
   EXPECT_TRUE(response->complete());
-  ASSERT(response->continueHeaders() != nullptr);
-  EXPECT_EQ("100", response->continueHeaders()->getStatusValue());
+  ASSERT(response->informationalHeaders() != nullptr);
+  EXPECT_EQ("100", response->informationalHeaders()->getStatusValue());
 
   EXPECT_EQ("200", response->headers().getStatusValue());
 }

test/integration/integration_stream_decoder.h

@@ -29,7 +29,7 @@ class IntegrationStreamDecoder : public Http::ResponseDecoder, public Http::Stre
   bool complete() { return saw_end_stream_; }
   bool reset() { return saw_reset_; }
   Http::StreamResetReason resetReason() { return reset_reason_; }
-  const Http::ResponseHeaderMap* continueHeaders() { return continue_headers_.get(); }
+  const Http::ResponseHeaderMap* informationalHeaders() { return continue_headers_.get(); }
   const Http::ResponseHeaderMap& headers() { return *headers_; }
   const Http::ResponseTrailerMapPtr& trailers() { return trailers_; }
   const Http::MetadataMap& metadataMap() { return *metadata_map_; }

test/mocks/http/mocks.cc

@@ -23,8 +23,8 @@ MockServerConnectionCallbacks::MockServerConnectionCallbacks() = default;
 MockServerConnectionCallbacks::~MockServerConnectionCallbacks() = default;
 
 MockFilterManagerCallbacks::MockFilterManagerCallbacks() {
-  ON_CALL(*this, continueHeaders()).WillByDefault(Invoke([this]() -> ResponseHeaderMapOptRef {
-    return makeOptRefFromPtr(continue_headers_.get());
+  ON_CALL(*this, informationalHeaders()).WillByDefault(Invoke([this]() -> ResponseHeaderMapOptRef {
+    return makeOptRefFromPtr(informational_headers_.get());
   }));
   ON_CALL(*this, responseHeaders()).WillByDefault(Invoke([this]() -> ResponseHeaderMapOptRef {
     return makeOptRefFromPtr(response_headers_.get());

test/mocks/http/mocks.h

@@ -65,10 +65,10 @@ class MockFilterManagerCallbacks : public FilterManagerCallbacks {
   MOCK_METHOD(void, encodeMetadata, (MetadataMapVector&));
   MOCK_METHOD(void, chargeStats, (const ResponseHeaderMap&));
   MOCK_METHOD(void, setRequestTrailers, (RequestTrailerMapPtr &&));
-  MOCK_METHOD(void, setContinueHeaders_, (ResponseHeaderMap&));
-  void setContinueHeaders(ResponseHeaderMapPtr&& continue_headers) override {
-    continue_headers_ = std::move(continue_headers);
-    setContinueHeaders_(*continue_headers_);
+  MOCK_METHOD(void, setInformationalHeaders_, (ResponseHeaderMap&));
+  void setInformationalHeaders(ResponseHeaderMapPtr&& informational_headers) override {
+    informational_headers_ = std::move(informational_headers);
+    setInformationalHeaders_(*informational_headers_);
   }
   MOCK_METHOD(void, setResponseHeaders_, (ResponseHeaderMap&));
   void setResponseHeaders(ResponseHeaderMapPtr&& response_headers) override {
@@ -82,7 +82,7 @@ class MockFilterManagerCallbacks : public FilterManagerCallbacks {
   }
   MOCK_METHOD(RequestHeaderMapOptRef, requestHeaders, ());
   MOCK_METHOD(RequestTrailerMapOptRef, requestTrailers, ());
-  MOCK_METHOD(ResponseHeaderMapOptRef, continueHeaders, ());
+  MOCK_METHOD(ResponseHeaderMapOptRef, informationalHeaders, ());
   MOCK_METHOD(ResponseHeaderMapOptRef, responseHeaders, ());
   MOCK_METHOD(ResponseTrailerMapOptRef, responseTrailers, ());
   MOCK_METHOD(void, endStream, ());
@@ -110,7 +110,7 @@ class MockFilterManagerCallbacks : public FilterManagerCallbacks {
   MOCK_METHOD(void, restoreContextOnContinue, (ScopeTrackedObjectStack&));
   MOCK_METHOD(bool, enableInternalRedirectsWithBody, (), (const));
 
-  ResponseHeaderMapPtr continue_headers_;
+  ResponseHeaderMapPtr informational_headers_;
   ResponseHeaderMapPtr response_headers_;
   ResponseTrailerMapPtr response_trailers_;
 };
@@ -233,7 +233,7 @@ class MockStreamDecoderFilterCallbacks : public StreamDecoderFilterCallbacks,
                        absl::string_view details);
 
   void encode1xxHeaders(ResponseHeaderMapPtr&& headers) override { encode1xxHeaders_(*headers); }
-  MOCK_METHOD(ResponseHeaderMapOptRef, continueHeaders, (), (const));
+  MOCK_METHOD(ResponseHeaderMapOptRef, informationalHeaders, (), (const));
   void encodeHeaders(ResponseHeaderMapPtr&& headers, bool end_stream,
                      absl::string_view details) override {
     stream_info_.setResponseCodeDetails(details);
@@ -402,7 +402,7 @@ class MockStreamFilter : public StreamFilter {
 
   // Http::MockStreamEncoderFilter
   MOCK_METHOD(FilterHeadersStatus, encode1xxHeaders, (ResponseHeaderMap & headers));
-  MOCK_METHOD(ResponseHeaderMapOptRef, continueHeaders, (), (const));
+  MOCK_METHOD(ResponseHeaderMapOptRef, informationalHeaders, (), (const));
   MOCK_METHOD(FilterHeadersStatus, encodeHeaders, (ResponseHeaderMap & headers, bool end_stream));
   MOCK_METHOD(ResponseHeaderMapOptRef, responseHeaders, (), (const));
   MOCK_METHOD(FilterDataStatus, encodeData, (Buffer::Instance & data, bool end_stream));