grpc 1.53.2 → 1.54.0

data/src/core/ext/gcp/metadata_query.cc

@@ -0,0 +1,142 @@
+//
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+//
+
+#include <grpc/support/port_platform.h>
+
+#include "src/core/ext/gcp/metadata_query.h"
+
+#include <string.h>
+
+#include <initializer_list>
+#include <memory>
+#include <utility>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/str_format.h"
+#include "absl/strings/string_view.h"
+
+#include <grpc/grpc.h>
+#include <grpc/grpc_security.h>
+#include <grpc/support/log.h>
+
+#include "src/core/lib/debug/trace.h"
+#include "src/core/lib/gprpp/ref_counted_ptr.h"
+#include "src/core/lib/gprpp/status_helper.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/security/credentials/credentials.h"
+#include "src/core/lib/uri/uri_parser.h"
+
+namespace grpc_core {
+
+TraceFlag grpc_metadata_query_trace(false, "metadata_query");
+
+constexpr const char MetadataQuery::kZoneAttribute[] =
+    "/computeMetadata/v1/instance/zone";
+constexpr const char MetadataQuery::kClusterNameAttribute[] =
+    "/computeMetadata/v1/instance/attributes/cluster-name";
+constexpr const char MetadataQuery::kRegionAttribute[] =
+    "/computeMetadata/v1/instance/region";
+constexpr const char MetadataQuery::kInstanceIdAttribute[] =
+    "/computeMetadata/v1/instance/id";
+constexpr const char MetadataQuery::kIPv6Attribute[] =
+    "/computeMetadata/v1/instance/network-interfaces/0/ipv6s";
+
+MetadataQuery::MetadataQuery(
+    std::string attribute, grpc_polling_entity* pollent,
+    absl::AnyInvocable<void(std::string /* attribute */,
+                            absl::StatusOr<std::string> /* result */)>
+        callback,
+    Duration timeout)
+    : MetadataQuery("metadata.google.internal.", std::move(attribute), pollent,
+                    std::move(callback), timeout) {}
+
+MetadataQuery::MetadataQuery(
+    std::string metadata_server_name, std::string attribute,
+    grpc_polling_entity* pollent,
+    absl::AnyInvocable<void(std::string /* attribute */,
+                            absl::StatusOr<std::string> /* result */)>
+        callback,
+    Duration timeout)
+    : InternallyRefCounted<MetadataQuery>(nullptr, 2),
+      attribute_(std::move(attribute)),
+      callback_(std::move(callback)) {
+  GRPC_CLOSURE_INIT(&on_done_, OnDone, this, nullptr);
+  auto uri = URI::Create("http", std::move(metadata_server_name), attribute_,
+                         {} /* query params */, "" /* fragment */);
+  GPR_ASSERT(uri.ok());  // params are hardcoded
+  grpc_http_request request;
+  memset(&request, 0, sizeof(grpc_http_request));
+  grpc_http_header header = {const_cast<char*>("Metadata-Flavor"),
+                             const_cast<char*>("Google")};
+  request.hdr_count = 1;
+  request.hdrs = &header;
+  http_request_ = HttpRequest::Get(
+      std::move(*uri), nullptr /* channel args */, pollent, &request,
+      Timestamp::Now() + timeout, &on_done_, &response_,
+      RefCountedPtr<grpc_channel_credentials>(
+          grpc_insecure_credentials_create()));
+  http_request_->Start();
+}
+
+MetadataQuery::~MetadataQuery() { grpc_http_response_destroy(&response_); }
+
+void MetadataQuery::Orphan() {
+  http_request_.reset();
+  Unref();
+}
+
+void MetadataQuery::OnDone(void* arg, grpc_error_handle error) {
+  auto* self = static_cast<MetadataQuery*>(arg);
+  if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
+    gpr_log(GPR_INFO, "MetadataServer Query for %s: HTTP status: %d, error: %s",
+            self->attribute_.c_str(), self->response_.status,
+            StatusToString(error).c_str());
+  }
+  absl::StatusOr<std::string> result;
+  if (!error.ok()) {
+    result = absl::UnavailableError(absl::StrFormat(
+        "MetadataServer Query failed for %s: %s", self->attribute_.c_str(),
+        StatusToString(error).c_str()));
+  } else if (self->response_.status != 200) {
+    result = absl::UnavailableError(absl::StrFormat(
+        "MetadataServer Query received non-200 status for %s: %s",
+        self->attribute_.c_str(), StatusToString(error).c_str()));
+  } else if (self->attribute_ == kZoneAttribute) {
+    absl::string_view body(self->response_.body, self->response_.body_length);
+    size_t pos = body.find_last_of('/');
+    if (pos == body.npos) {
+      result = absl::UnavailableError(
+          absl::StrFormat("MetadataServer Could not parse zone: %s",
+                          std::string(body).c_str()));
+      if (GRPC_TRACE_FLAG_ENABLED(grpc_metadata_query_trace)) {
+        gpr_log(GPR_INFO, "%s", result.status().ToString().c_str());
+      }
+    } else {
+      result = std::string(body.substr(pos + 1));
+    }
+  } else {
+    result = std::string(self->response_.body, self->response_.body_length);
+  }
+  auto callback = std::move(self->callback_);
+  auto attribute = std::move(self->attribute_);
+  self->Unref();
+  return callback(std::move(attribute), std::move(result));
+}
+
+}  // namespace grpc_core

data/src/core/ext/gcp/metadata_query.h

@@ -0,0 +1,82 @@
+//
+// Copyright 2023 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
+#define GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H
+
+#include <grpc/support/port_platform.h>
+
+#include <string>
+
+#include "absl/functional/any_invocable.h"
+#include "absl/status/statusor.h"
+
+#include "src/core/lib/gprpp/orphanable.h"
+#include "src/core/lib/gprpp/time.h"
+#include "src/core/lib/http/httpcli.h"
+#include "src/core/lib/http/parser.h"
+#include "src/core/lib/iomgr/closure.h"
+#include "src/core/lib/iomgr/error.h"
+#include "src/core/lib/iomgr/polling_entity.h"
+
+namespace grpc_core {
+
+// Fetches the value of an attribute from the MetadataServer on a GCP
+// environment.
+class MetadataQuery : public InternallyRefCounted<MetadataQuery> {
+ public:
+  static const char kZoneAttribute[];
+  static const char kClusterNameAttribute[];
+  static const char kRegionAttribute[];
+  static const char kInstanceIdAttribute[];
+  static const char kIPv6Attribute[];
+
+  MetadataQuery(
+      std::string attribute, grpc_polling_entity* pollent,
+      absl::AnyInvocable<void(std::string /* attribute */,
+                              absl::StatusOr<std::string> /* result */)>
+          callback,
+      Duration timeout);
+
+  // Alternative ctor allows overriding the metadata server address, mainly
+  // to inject fakes in tests
+  MetadataQuery(
+      std::string metadata_server_name, std::string attribute,
+      grpc_polling_entity* pollent,
+      absl::AnyInvocable<void(std::string /* attribute */,
+                              absl::StatusOr<std::string> /* result */)>
+          callback,
+      Duration timeout);
+
+  ~MetadataQuery() override;
+
+  void Orphan() override;
+
+ private:
+  static void OnDone(void* arg, grpc_error_handle error);
+
+  grpc_closure on_done_;
+  std::string attribute_;
+  absl::AnyInvocable<void(std::string /* attribute */,
+                          absl::StatusOr<std::string> /* result */)>
+      callback_;
+  OrphanablePtr<HttpRequest> http_request_;
+  grpc_http_response response_;
+};
+
+}  // namespace grpc_core
+
+#endif  // GRPC_SRC_CORE_EXT_GCP_METADATA_QUERY_H

data/src/core/ext/transport/chttp2/server/chttp2_server.cc

@@ -40,6 +40,7 @@
 #include "absl/strings/strip.h"
 #include "absl/types/optional.h"
 
+#include <grpc/event_engine/event_engine.h>
 #include <grpc/grpc.h>
 #include <grpc/grpc_posix.h>
 #include <grpc/slice_buffer.h>
@@ -69,7 +70,6 @@
 #include "src/core/lib/iomgr/resolve_address.h"
 #include "src/core/lib/iomgr/resolved_address.h"
 #include "src/core/lib/iomgr/tcp_server.h"
-#include "src/core/lib/iomgr/timer.h"
 #include "src/core/lib/iomgr/unix_sockets_posix.h"
 #include "src/core/lib/resource_quota/memory_quota.h"
 #include "src/core/lib/resource_quota/resource_quota.h"
@@ -94,6 +94,8 @@
 namespace grpc_core {
 namespace {
 
+using ::grpc_event_engine::experimental::EventEngine;
+
 const char kUnixUriPrefix[] = "unix:";
 const char kUnixAbstractUriPrefix[] = "unix-abstract:";
 
@@ -161,7 +163,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
       using InternallyRefCounted<HandshakingState>::Ref;
 
      private:
-      static void OnTimeout(void* arg, grpc_error_handle error);
+      void OnTimeout() ABSL_LOCKS_EXCLUDED(&connection_->mu_);
       static void OnReceiveSettings(void* arg, grpc_error_handle /* error */);
       static void OnHandshakeDone(void* arg, grpc_error_handle error);
       RefCountedPtr<ActiveConnection> const connection_;
@@ -171,15 +173,16 @@ class Chttp2ServerListener : public Server::ListenerInterface {
           ABSL_GUARDED_BY(&connection_->mu_);
       // State for enforcing handshake timeout on receiving HTTP/2 settings.
       Timestamp const deadline_;
-      grpc_timer timer_ ABSL_GUARDED_BY(&connection_->mu_);
-      grpc_closure on_timeout_ ABSL_GUARDED_BY(&connection_->mu_);
+      absl::optional<EventEngine::TaskHandle> timer_handle_
+          ABSL_GUARDED_BY(&connection_->mu_);
       grpc_closure on_receive_settings_ ABSL_GUARDED_BY(&connection_->mu_);
       grpc_pollset_set* const interested_parties_;
     };
 
     ActiveConnection(grpc_pollset* accepting_pollset,
                      grpc_tcp_server_acceptor* acceptor,
-                     const ChannelArgs& args, MemoryOwner memory_owner);
+                     EventEngine* event_engine, const ChannelArgs& args,
+                     MemoryOwner memory_owner);
     ~ActiveConnection() override;
 
     void Orphan() override;
@@ -195,7 +198,7 @@ class Chttp2ServerListener : public Server::ListenerInterface {
 
    private:
     static void OnClose(void* arg, grpc_error_handle error);
-    static void OnDrainGraceTimeExpiry(void* arg, grpc_error_handle error);
+    void OnDrainGraceTimeExpiry() ABSL_LOCKS_EXCLUDED(&mu_);
 
     RefCountedPtr<Chttp2ServerListener> listener_;
     Mutex mu_ ABSL_ACQUIRED_AFTER(&listener_->mu_);
@@ -206,10 +209,11 @@ class Chttp2ServerListener : public Server::ListenerInterface {
     // is created.
     grpc_chttp2_transport* transport_ ABSL_GUARDED_BY(&mu_) = nullptr;
     grpc_closure on_close_;
-    grpc_timer drain_grace_timer_;
-    grpc_closure on_drain_grace_time_expiry_;
-    bool drain_grace_timer_expiry_callback_pending_ ABSL_GUARDED_BY(&mu_) =
-        false;
+    absl::optional<EventEngine::TaskHandle> drain_grace_timer_handle_
+        ABSL_GUARDED_BY(&mu_);
+    // Use a raw pointer since this event_engine_ is grabbed from the
+    // ChannelArgs of the listener_.
+    EventEngine* const event_engine_ ABSL_GUARDED_BY(&mu_);
     bool shutdown_ ABSL_GUARDED_BY(&mu_) = false;
   };
 
@@ -408,29 +412,33 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::Start(
                              OnHandshakeDone, this);
 }
 
-void Chttp2ServerListener::ActiveConnection::HandshakingState::OnTimeout(
-    void* arg, grpc_error_handle error) {
-  HandshakingState* self = static_cast<HandshakingState*>(arg);
-  // Note that we may be called with absl::OkStatus() when the timer fires
-  // or with an error indicating that the timer system is being shut down.
-  if (error != absl::CancelledError()) {
+void Chttp2ServerListener::ActiveConnection::HandshakingState::OnTimeout() {
+  grpc_chttp2_transport* transport = nullptr;
+  {
+    MutexLock lock(&connection_->mu_);
+    if (timer_handle_.has_value()) {
+      transport = connection_->transport_;
+      timer_handle_.reset();
+    }
+  }
+  if (transport != nullptr) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->disconnect_with_error = GRPC_ERROR_CREATE(
         "Did not receive HTTP/2 settings before handshake timeout");
-    grpc_chttp2_transport* transport = nullptr;
-    {
-      MutexLock lock(&self->connection_->mu_);
-      transport = self->connection_->transport_;
-    }
     grpc_transport_perform_op(&transport->base, op);
   }
-  self->Unref();
 }
 
 void Chttp2ServerListener::ActiveConnection::HandshakingState::
     OnReceiveSettings(void* arg, grpc_error_handle /* error */) {
   HandshakingState* self = static_cast<HandshakingState*>(arg);
-  grpc_timer_cancel(&self->timer_);
+  {
+    MutexLock lock(&self->connection_->mu_);
+    if (self->timer_handle_.has_value()) {
+      self->connection_->event_engine_->Cancel(*self->timer_handle_);
+      self->timer_handle_.reset();
+    }
+  }
   self->Unref();
 }
 
@@ -503,10 +511,15 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
           grpc_chttp2_transport_start_reading(transport, args->read_buffer,
                                               &self->on_receive_settings_,
                                               on_close);
-          self->Ref().release();  // Held by OnTimeout().
-          GRPC_CLOSURE_INIT(&self->on_timeout_, OnTimeout, self,
-                            grpc_schedule_on_exec_ctx);
-          grpc_timer_init(&self->timer_, self->deadline_, &self->on_timeout_);
+          self->timer_handle_ = self->connection_->event_engine_->RunAfter(
+              self->deadline_ - Timestamp::Now(),
+              [self = self->Ref()]() mutable {
+                ApplicationCallbackExecCtx callback_exec_ctx;
+                ExecCtx exec_ctx;
+                self->OnTimeout();
+                // HandshakingState deletion might require an active ExecCtx.
+                self.reset();
+              });
         } else {
           // Failed to create channel from transport. Clean up.
           gpr_log(GPR_ERROR, "Failed to create channel: %s",
@@ -548,9 +561,11 @@ void Chttp2ServerListener::ActiveConnection::HandshakingState::OnHandshakeDone(
 
 Chttp2ServerListener::ActiveConnection::ActiveConnection(
     grpc_pollset* accepting_pollset, grpc_tcp_server_acceptor* acceptor,
-    const ChannelArgs& args, MemoryOwner memory_owner)
+    EventEngine* event_engine, const ChannelArgs& args,
+    MemoryOwner memory_owner)
     : handshaking_state_(memory_owner.MakeOrphanable<HandshakingState>(
-          Ref(), accepting_pollset, acceptor, args)) {
+          Ref(), accepting_pollset, acceptor, args)),
+      event_engine_(event_engine) {
   GRPC_CLOSURE_INIT(&on_close_, ActiveConnection::OnClose, this,
                     grpc_schedule_on_exec_ctx);
 }
@@ -579,20 +594,18 @@ void Chttp2ServerListener::ActiveConnection::SendGoAway() {
     MutexLock lock(&mu_);
     if (transport_ != nullptr && !shutdown_) {
       transport = transport_;
-      Ref().release();  // Ref held by OnDrainGraceTimeExpiry
-      GRPC_CLOSURE_INIT(&on_drain_grace_time_expiry_, OnDrainGraceTimeExpiry,
-                        this, nullptr);
-      grpc_timer_init(
-          &drain_grace_timer_,
-          Timestamp::Now() +
-              std::max(
-                  Duration::Zero(),
-                  listener_->args_
-                      .GetDurationFromIntMillis(
-                          GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS)
-                      .value_or(Duration::Minutes(10))),
-          &on_drain_grace_time_expiry_);
-      drain_grace_timer_expiry_callback_pending_ = true;
+      drain_grace_timer_handle_ = event_engine_->RunAfter(
+          std::max(Duration::Zero(),
+                   listener_->args_
+                       .GetDurationFromIntMillis(
+                           GRPC_ARG_SERVER_CONFIG_CHANGE_DRAIN_GRACE_TIME_MS)
+                       .value_or(Duration::Minutes(10))),
+          [self = Ref(DEBUG_LOCATION, "drain_grace_timer")]() mutable {
+            ApplicationCallbackExecCtx callback_exec_ctx;
+            ExecCtx exec_ctx;
+            self->OnDrainGraceTimeExpiry();
+            self.reset(DEBUG_LOCATION, "drain_grace_timer");
+          });
       shutdown_ = true;
     }
   }
@@ -637,30 +650,31 @@ void Chttp2ServerListener::ActiveConnection::OnClose(
       self->shutdown_ = true;
     }
     // Cancel the drain_grace_timer_ if needed.
-    if (self->drain_grace_timer_expiry_callback_pending_) {
-      grpc_timer_cancel(&self->drain_grace_timer_);
+    if (self->drain_grace_timer_handle_.has_value()) {
+      self->event_engine_->Cancel(*self->drain_grace_timer_handle_);
+      self->drain_grace_timer_handle_.reset();
     }
   }
   self->Unref();
 }
 
-void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry(
-    void* arg, grpc_error_handle error) {
-  ActiveConnection* self = static_cast<ActiveConnection*>(arg);
+void Chttp2ServerListener::ActiveConnection::OnDrainGraceTimeExpiry() {
+  grpc_chttp2_transport* transport = nullptr;
   // If the drain_grace_timer_ was not cancelled, disconnect the transport
   // immediately.
-  if (error.ok()) {
-    grpc_chttp2_transport* transport = nullptr;
-    {
-      MutexLock lock(&self->mu_);
-      transport = self->transport_;
+  {
+    MutexLock lock(&mu_);
+    if (drain_grace_timer_handle_.has_value()) {
+      transport = transport_;
+      drain_grace_timer_handle_.reset();
     }
+  }
+  if (transport != nullptr) {
     grpc_transport_op* op = grpc_make_transport_op(nullptr);
     op->disconnect_with_error = GRPC_ERROR_CREATE(
         "Drain grace time expired. Closing connection immediately.");
     grpc_transport_perform_op(&transport->base, op);
   }
-  self->Unref();
 }
 
 //
@@ -830,8 +844,9 @@ void Chttp2ServerListener::OnAccept(void* arg, grpc_endpoint* tcp,
   }
   auto memory_owner = self->memory_quota_->CreateMemoryOwner(
       absl::StrCat(grpc_endpoint_get_peer(tcp), ":server_channel"));
+  EventEngine* const event_engine = self->args_.GetObject<EventEngine>();
   auto connection = memory_owner.MakeOrphanable<ActiveConnection>(
-      accepting_pollset, acceptor, args, std::move(memory_owner));
+      accepting_pollset, acceptor, event_engine, args, std::move(memory_owner));
   // We no longer own acceptor
   acceptor = nullptr;
   // Hold a ref to connection to allow starting handshake outside the

data/src/core/ext/transport/chttp2/transport/bin_encoder.cc

@@ -149,8 +149,7 @@ static void enc_flush_some(huff_out* out) {
   }
 }
 
-static void enc_add2(huff_out* out, uint8_t a, uint8_t b, uint32_t* wire_size) {
-  *wire_size += 2;
+static void enc_add2(huff_out* out, uint8_t a, uint8_t b) {
   b64_huff_sym sa = huff_alphabet[a];
   b64_huff_sym sb = huff_alphabet[b];
   out->temp = (out->temp << (sa.length + sb.length)) |
@@ -160,8 +159,7 @@ static void enc_add2(huff_out* out, uint8_t a, uint8_t b, uint32_t* wire_size) {
   enc_flush_some(out);
 }
 
-static void enc_add1(huff_out* out, uint8_t a, uint32_t* wire_size) {
-  *wire_size += 1;
+static void enc_add1(huff_out* out, uint8_t a) {
   b64_huff_sym sa = huff_alphabet[a];
   out->temp = (out->temp << sa.length) | sa.bits;
   out->temp_length += sa.length;
@@ -169,7 +167,7 @@ static void enc_add1(huff_out* out, uint8_t a, uint32_t* wire_size) {
 }
 
 grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
-    const grpc_slice& input, uint32_t* wire_size) {
+    const grpc_slice& input) {
   size_t input_length = GRPC_SLICE_LENGTH(input);
   size_t input_triplets = input_length / 3;
   size_t tail_case = input_length % 3;
@@ -185,17 +183,16 @@ grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
   out.temp = 0;
   out.temp_length = 0;
   out.out = start_out;
-  *wire_size = 0;
 
   // encode full triplets
   for (i = 0; i < input_triplets; i++) {
     const uint8_t low_to_high = static_cast<uint8_t>((in[0] & 0x3) << 4);
     const uint8_t high_to_low = in[1] >> 4;
-    enc_add2(&out, in[0] >> 2, low_to_high | high_to_low, wire_size);
+    enc_add2(&out, in[0] >> 2, low_to_high | high_to_low);
 
     const uint8_t a = static_cast<uint8_t>((in[1] & 0xf) << 2);
     const uint8_t b = (in[2] >> 6);
-    enc_add2(&out, a | b, in[2] & 0x3f, wire_size);
+    enc_add2(&out, a | b, in[2] & 0x3f);
     in += 3;
   }
 
@@ -204,15 +201,14 @@ grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
     case 0:
       break;
     case 1:
-      enc_add2(&out, in[0] >> 2, static_cast<uint8_t>((in[0] & 0x3) << 4),
-               wire_size);
+      enc_add2(&out, in[0] >> 2, static_cast<uint8_t>((in[0] & 0x3) << 4));
       in += 1;
       break;
     case 2: {
       const uint8_t low_to_high = static_cast<uint8_t>((in[0] & 0x3) << 4);
       const uint8_t high_to_low = in[1] >> 4;
-      enc_add2(&out, in[0] >> 2, low_to_high | high_to_low, wire_size);
-      enc_add1(&out, static_cast<uint8_t>((in[1] & 0xf) << 2), wire_size);
+      enc_add2(&out, in[0] >> 2, low_to_high | high_to_low);
+      enc_add1(&out, static_cast<uint8_t>((in[1] & 0xf) << 2));
       in += 2;
       break;
     }

data/src/core/ext/transport/chttp2/transport/bin_encoder.h

@@ -21,8 +21,6 @@
 
 #include <grpc/support/port_platform.h>
 
-#include <stdint.h>
-
 #include <grpc/slice.h>
 
 // base64 encode a slice. Returns a new slice, does not take ownership of the
@@ -38,9 +36,7 @@ grpc_slice grpc_chttp2_huffman_compress(const grpc_slice& input);
 // grpc_slice y = grpc_chttp2_huffman_compress(x);
 // grpc_core::CSliceUnref( x);
 // return y;
-// *wire_size is the length of the base64 encoded string prior to huffman
-// compression (as is needed for hpack table math)
 grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
-    const grpc_slice& input, uint32_t* wire_size);
+    const grpc_slice& input);
 
 #endif  // GRPC_SRC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_ENCODER_H