Update Envoy to 867b9e23d2e48350bd1b0d1fbc392a8355f20e35

bazel/repositories.bzl

@@ -1,7 +1,7 @@
 load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
 
-ENVOY_COMMIT = "424909395c90d7d68f1afeb3427c26c7c85f2672"  # December 11th, 2020
-ENVOY_SHA = "d80514bcb2ea0f124681d7a05535f724846d5cef2a455f9b2d1d9a29c3ab5740"
+ENVOY_COMMIT = "867b9e23d2e48350bd1b0d1fbc392a8355f20e35"  # December 20th, 2020
+ENVOY_SHA = "b98a88bbff0c64ff08f88d2a4379dd708d1df012424d6b65c7e32773ce249a53"
 
 HDR_HISTOGRAM_C_VERSION = "0.11.2"  # October 12th, 2020
 HDR_HISTOGRAM_C_SHA = "637f28b5f64de2e268131e4e34e6eef0b91cf5ff99167db447d9b2825eae6bad"

source/client/process_impl.cc

@@ -66,10 +66,18 @@ class ClusterManagerFactory : public Envoy::Upstream::ProdClusterManagerFactory
 
   Envoy::Http::ConnectionPool::InstancePtr
   allocateConnPool(Envoy::Event::Dispatcher& dispatcher, Envoy::Upstream::HostConstSharedPtr host,
-                   Envoy::Upstream::ResourcePriority priority, Envoy::Http::Protocol protocol,
+                   Envoy::Upstream::ResourcePriority priority,
+                   std::vector<Envoy::Http::Protocol>& protocols,
                    const Envoy::Network::ConnectionSocket::OptionsSharedPtr& options,
                    const Envoy::Network::TransportSocketOptionsSharedPtr& transport_socket_options,
                    Envoy::Upstream::ClusterConnectivityState& state) override {
+    // This changed in
+    // https://github.com/envoyproxy/envoy/commit/93ee668a690d297ab5e8bd2cbf03771d852ebbda ALPN may
+    // be set up to negotiate a protocol, in which case we'd need a HttpConnPoolImplMixed. However,
+    // our integration tests pass, and for now this might suffice. In case we do run into the need
+    // for supporting multiple procols in a single pool, ensure we hear about it soon, by asserting.
+    RELEASE_ASSERT(protocols.size() == 1, "Expected a single protocol in protocols vector.");
+    const Envoy::Http::Protocol& protocol = protocols[0];
     if (protocol == Envoy::Http::Protocol::Http11 || protocol == Envoy::Http::Protocol::Http10) {
       auto* h1_pool = new Http1PoolImpl(
           host, priority, dispatcher, options, transport_socket_options, api_.randomGenerator(),
@@ -84,13 +92,13 @@ class ClusterManagerFactory : public Envoy::Upstream::ProdClusterManagerFactory
                 data.host_description_, pool->dispatcher(), pool->randomGenerator())};
             return codec;
           },
-          std::vector<Envoy::Http::Protocol>{protocol});
+          protocols);
       h1_pool->setConnectionReuseStrategy(connection_reuse_strategy_);
       h1_pool->setPrefetchConnections(prefetch_connections_);
       return Envoy::Http::ConnectionPool::InstancePtr{h1_pool};
     }
     return Envoy::Upstream::ProdClusterManagerFactory::allocateConnPool(
-        dispatcher, host, priority, protocol, options, transport_socket_options, state);
+        dispatcher, host, priority, protocols, options, transport_socket_options, state);
   }
 
   void setConnectionReuseStrategy(

test/mocks/client/mock_benchmark_client.h

@@ -11,13 +11,13 @@ class MockBenchmarkClient : public BenchmarkClient {
 public:
   MockBenchmarkClient();
 
-  MOCK_METHOD0(terminate, void());
-  MOCK_METHOD1(setShouldMeasureLatencies, void(bool));
-  MOCK_CONST_METHOD0(statistics, StatisticPtrMap());
-  MOCK_METHOD1(tryStartRequest, bool(Client::CompletionCallback));
-  MOCK_CONST_METHOD0(scope, Envoy::Stats::Scope&());
-  MOCK_CONST_METHOD0(shouldMeasureLatencies, bool());
-  MOCK_CONST_METHOD0(requestHeaders, const Envoy::Http::RequestHeaderMap&());
+  MOCK_METHOD(void, terminate, ());
+  MOCK_METHOD(void, setShouldMeasureLatencies, (bool));
+  MOCK_METHOD(StatisticPtrMap, statistics, (), (const));
+  MOCK_METHOD(bool, tryStartRequest, (Client::CompletionCallback));
+  MOCK_METHOD(Envoy::Stats::Scope&, scope, (), (const));
+  MOCK_METHOD(bool, shouldMeasureLatencies, (), (const));
+  MOCK_METHOD(const Envoy::Http::RequestHeaderMap&, requestHeaders, (), (const));
 };
 
 } // namespace Client

test/mocks/common/mock_rate_limiter.h

@@ -10,19 +10,19 @@ class MockRateLimiter : public RateLimiter {
 public:
   MockRateLimiter();
 
-  MOCK_METHOD0(tryAcquireOne, bool());
-  MOCK_METHOD0(releaseOne, void());
-  MOCK_METHOD0(timeSource, Envoy::TimeSource&());
-  MOCK_METHOD0(elapsed, std::chrono::nanoseconds());
-  MOCK_CONST_METHOD0(firstAcquisitionTime, absl::optional<Envoy::SystemTime>());
+  MOCK_METHOD(bool, tryAcquireOne, ());
+  MOCK_METHOD(void, releaseOne, ());
+  MOCK_METHOD(Envoy::TimeSource&, timeSource, ());
+  MOCK_METHOD(std::chrono::nanoseconds, elapsed, ());
+  MOCK_METHOD(absl::optional<Envoy::SystemTime>, firstAcquisitionTime, (), (const));
 };
 
 class MockDiscreteNumericDistributionSampler : public DiscreteNumericDistributionSampler {
 public:
   MockDiscreteNumericDistributionSampler();
-  MOCK_METHOD0(getValue, uint64_t());
-  MOCK_CONST_METHOD0(min, uint64_t());
-  MOCK_CONST_METHOD0(max, uint64_t());
+  MOCK_METHOD(uint64_t, getValue, ());
+  MOCK_METHOD(uint64_t, min, (), (const));
+  MOCK_METHOD(uint64_t, max, (), (const));
 };
 
 } // namespace Nighthawk

test/mocks/common/mock_request_source.h

@@ -9,8 +9,8 @@ namespace Nighthawk {
 class MockRequestSource : public RequestSource {
 public:
   MockRequestSource();
-  MOCK_METHOD0(get, RequestGenerator());
-  MOCK_METHOD0(initOnThread, void());
+  MOCK_METHOD(RequestGenerator, get, ());
+  MOCK_METHOD(void, initOnThread, ());
 };
 
 } // namespace Nighthawk

test/mocks/common/mock_sequencer.h

@@ -11,13 +11,13 @@ class MockSequencer : public Sequencer {
 public:
   MockSequencer();
 
-  MOCK_METHOD0(start, void());
-  MOCK_METHOD0(waitForCompletion, void());
-  MOCK_CONST_METHOD0(completionsPerSecond, double());
-  MOCK_CONST_METHOD0(executionDuration, std::chrono::nanoseconds());
-  MOCK_CONST_METHOD0(statistics, StatisticPtrMap());
-  MOCK_METHOD0(cancel, void());
-  MOCK_CONST_METHOD0(rate_limiter, RateLimiter&());
+  MOCK_METHOD(void, start, ());
+  MOCK_METHOD(void, waitForCompletion, ());
+  MOCK_METHOD(double, completionsPerSecond, (), (const));
+  MOCK_METHOD(std::chrono::nanoseconds, executionDuration, (), (const));
+  MOCK_METHOD(StatisticPtrMap, statistics, (), (const));
+  MOCK_METHOD(void, cancel, ());
+  MOCK_METHOD(RateLimiter&, rate_limiter, (), (const));
 };
 
 } // namespace Nighthawk

test/mocks/common/mock_termination_predicate.h

@@ -9,10 +9,10 @@ namespace Nighthawk {
 class MockTerminationPredicate : public TerminationPredicate {
 public:
   MockTerminationPredicate();
-  MOCK_METHOD1(link, TerminationPredicate&(TerminationPredicatePtr&&));
-  MOCK_METHOD1(appendToChain, TerminationPredicate&(TerminationPredicatePtr&&));
-  MOCK_METHOD0(evaluateChain, TerminationPredicate::Status());
-  MOCK_METHOD0(evaluate, TerminationPredicate::Status());
+  MOCK_METHOD(TerminationPredicate&, link, (TerminationPredicatePtr && p));
+  MOCK_METHOD(TerminationPredicate&, appendToChain, (TerminationPredicatePtr && p));
+  MOCK_METHOD(TerminationPredicate::Status, evaluateChain, ());
+  MOCK_METHOD(TerminationPredicate::Status, evaluate, ());
 };
 
 } // namespace Nighthawk

test/sequencer_test.cc

@@ -34,7 +34,7 @@ class FakeSequencerTarget {
 
 class MockSequencerTarget : public FakeSequencerTarget {
 public:
-  MOCK_METHOD1(callback, bool(OperationCallback));
+  MOCK_METHOD(bool, callback, (OperationCallback));
 };
 
 class SequencerTestBase : public testing::Test {