grpc 1.18.0 → 1.22.0

data/src/core/ext/transport/chttp2/client/secure/secure_channel_create.cc

@@ -40,157 +40,148 @@
 #include "src/core/lib/surface/channel.h"
 #include "src/core/lib/uri/uri_parser.h"
 
-static void client_channel_factory_ref(
-    grpc_client_channel_factory* cc_factory) {}
+namespace grpc_core {
 
-static void client_channel_factory_unref(
-    grpc_client_channel_factory* cc_factory) {}
-
-static grpc_subchannel_args* get_secure_naming_subchannel_args(
-    const grpc_subchannel_args* args) {
-  grpc_channel_credentials* channel_credentials =
-      grpc_channel_credentials_find_in_args(args->args);
-  if (channel_credentials == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Can't create subchannel: channel credentials missing for secure "
-            "channel.");
-    return nullptr;
-  }
-  // Make sure security connector does not already exist in args.
-  if (grpc_security_connector_find_in_args(args->args) != nullptr) {
-    gpr_log(GPR_ERROR,
-            "Can't create subchannel: security connector already present in "
-            "channel args.");
-    return nullptr;
-  }
-  // To which address are we connecting? By default, use the server URI.
-  const grpc_arg* server_uri_arg =
-      grpc_channel_args_find(args->args, GRPC_ARG_SERVER_URI);
-  const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
-  GPR_ASSERT(server_uri_str != nullptr);
-  grpc_uri* server_uri =
-      grpc_uri_parse(server_uri_str, true /* supress errors */);
-  GPR_ASSERT(server_uri != nullptr);
-  const grpc_core::TargetAuthorityTable* target_authority_table =
-      grpc_core::FindTargetAuthorityTableInArgs(args->args);
-  grpc_core::UniquePtr<char> authority;
-  if (target_authority_table != nullptr) {
-    // Find the authority for the target.
-    const char* target_uri_str =
-        grpc_get_subchannel_address_uri_arg(args->args);
-    grpc_uri* target_uri =
-        grpc_uri_parse(target_uri_str, false /* suppress errors */);
-    GPR_ASSERT(target_uri != nullptr);
-    if (target_uri->path[0] != '\0') {  // "path" may be empty
-      const grpc_slice key = grpc_slice_from_static_string(
-          target_uri->path[0] == '/' ? target_uri->path + 1 : target_uri->path);
-      const grpc_core::UniquePtr<char>* value =
-          target_authority_table->Get(key);
-      if (value != nullptr) authority.reset(gpr_strdup(value->get()));
-      grpc_slice_unref_internal(key);
+class Chttp2SecureClientChannelFactory : public ClientChannelFactory {
+ public:
+  Subchannel* CreateSubchannel(const grpc_channel_args* args) override {
+    grpc_channel_args* new_args = GetSecureNamingChannelArgs(args);
+    if (new_args == nullptr) {
+      gpr_log(GPR_ERROR,
+              "Failed to create channel args during subchannel creation.");
+      return nullptr;
     }
-    grpc_uri_destroy(target_uri);
-  }
-  // If the authority hasn't already been set (either because no target
-  // authority table was present or because the target was not present
-  // in the table), fall back to using the original server URI.
-  if (authority == nullptr) {
-    authority =
-        grpc_core::ResolverRegistry::GetDefaultAuthority(server_uri_str);
+    grpc_connector* connector = grpc_chttp2_connector_create();
+    Subchannel* s = Subchannel::Create(connector, new_args);
+    grpc_connector_unref(connector);
+    grpc_channel_args_destroy(new_args);
+    return s;
   }
-  grpc_arg args_to_add[2];
-  size_t num_args_to_add = 0;
-  if (grpc_channel_args_find(args->args, GRPC_ARG_DEFAULT_AUTHORITY) ==
-      nullptr) {
-    // If the channel args don't already contain GRPC_ARG_DEFAULT_AUTHORITY, add
-    // the arg, setting it to the value just obtained.
-    args_to_add[num_args_to_add++] = grpc_channel_arg_string_create(
-        const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY), authority.get());
+
+  grpc_channel* CreateChannel(const char* target,
+                              const grpc_channel_args* args) override {
+    if (target == nullptr) {
+      gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
+      return nullptr;
+    }
+    // Add channel arg containing the server URI.
+    UniquePtr<char> canonical_target =
+        ResolverRegistry::AddDefaultPrefixIfNeeded(target);
+    grpc_arg arg = grpc_channel_arg_string_create(
+        const_cast<char*>(GRPC_ARG_SERVER_URI), canonical_target.get());
+    const char* to_remove[] = {GRPC_ARG_SERVER_URI};
+    grpc_channel_args* new_args =
+        grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
+    grpc_channel* channel =
+        grpc_channel_create(target, new_args, GRPC_CLIENT_CHANNEL, nullptr);
+    grpc_channel_args_destroy(new_args);
+    return channel;
   }
-  grpc_channel_args* args_with_authority =
-      grpc_channel_args_copy_and_add(args->args, args_to_add, num_args_to_add);
-  grpc_uri_destroy(server_uri);
-  // Create the security connector using the credentials and target name.
-  grpc_channel_args* new_args_from_connector = nullptr;
-  grpc_core::RefCountedPtr<grpc_channel_security_connector>
-      subchannel_security_connector =
-          channel_credentials->create_security_connector(
-              /*call_creds=*/nullptr, authority.get(), args_with_authority,
-              &new_args_from_connector);
-  if (subchannel_security_connector == nullptr) {
-    gpr_log(GPR_ERROR,
-            "Failed to create secure subchannel for secure name '%s'",
-            authority.get());
+
+ private:
+  static grpc_channel_args* GetSecureNamingChannelArgs(
+      const grpc_channel_args* args) {
+    grpc_channel_credentials* channel_credentials =
+        grpc_channel_credentials_find_in_args(args);
+    if (channel_credentials == nullptr) {
+      gpr_log(GPR_ERROR,
+              "Can't create subchannel: channel credentials missing for secure "
+              "channel.");
+      return nullptr;
+    }
+    // Make sure security connector does not already exist in args.
+    if (grpc_security_connector_find_in_args(args) != nullptr) {
+      gpr_log(GPR_ERROR,
+              "Can't create subchannel: security connector already present in "
+              "channel args.");
+      return nullptr;
+    }
+    // To which address are we connecting? By default, use the server URI.
+    const grpc_arg* server_uri_arg =
+        grpc_channel_args_find(args, GRPC_ARG_SERVER_URI);
+    const char* server_uri_str = grpc_channel_arg_get_string(server_uri_arg);
+    GPR_ASSERT(server_uri_str != nullptr);
+    grpc_uri* server_uri =
+        grpc_uri_parse(server_uri_str, true /* suppress errors */);
+    GPR_ASSERT(server_uri != nullptr);
+    const TargetAuthorityTable* target_authority_table =
+        FindTargetAuthorityTableInArgs(args);
+    UniquePtr<char> authority;
+    if (target_authority_table != nullptr) {
+      // Find the authority for the target.
+      const char* target_uri_str =
+          Subchannel::GetUriFromSubchannelAddressArg(args);
+      grpc_uri* target_uri =
+          grpc_uri_parse(target_uri_str, false /* suppress errors */);
+      GPR_ASSERT(target_uri != nullptr);
+      if (target_uri->path[0] != '\0') {  // "path" may be empty
+        const grpc_slice key = grpc_slice_from_static_string(
+            target_uri->path[0] == '/' ? target_uri->path + 1
+                                       : target_uri->path);
+        const UniquePtr<char>* value = target_authority_table->Get(key);
+        if (value != nullptr) authority.reset(gpr_strdup(value->get()));
+        grpc_slice_unref_internal(key);
+      }
+      grpc_uri_destroy(target_uri);
+    }
+    // If the authority hasn't already been set (either because no target
+    // authority table was present or because the target was not present
+    // in the table), fall back to using the original server URI.
+    if (authority == nullptr) {
+      authority = ResolverRegistry::GetDefaultAuthority(server_uri_str);
+    }
+    grpc_arg args_to_add[2];
+    size_t num_args_to_add = 0;
+    if (grpc_channel_args_find(args, GRPC_ARG_DEFAULT_AUTHORITY) == nullptr) {
+      // If the channel args don't already contain GRPC_ARG_DEFAULT_AUTHORITY,
+      // add the arg, setting it to the value just obtained.
+      args_to_add[num_args_to_add++] = grpc_channel_arg_string_create(
+          const_cast<char*>(GRPC_ARG_DEFAULT_AUTHORITY), authority.get());
+    }
+    grpc_channel_args* args_with_authority =
+        grpc_channel_args_copy_and_add(args, args_to_add, num_args_to_add);
+    grpc_uri_destroy(server_uri);
+    // Create the security connector using the credentials and target name.
+    grpc_channel_args* new_args_from_connector = nullptr;
+    RefCountedPtr<grpc_channel_security_connector>
+        subchannel_security_connector =
+            channel_credentials->create_security_connector(
+                /*call_creds=*/nullptr, authority.get(), args_with_authority,
+                &new_args_from_connector);
+    if (subchannel_security_connector == nullptr) {
+      gpr_log(GPR_ERROR,
+              "Failed to create secure subchannel for secure name '%s'",
+              authority.get());
+      grpc_channel_args_destroy(args_with_authority);
+      return nullptr;
+    }
+    grpc_arg new_security_connector_arg =
+        grpc_security_connector_to_arg(subchannel_security_connector.get());
+    grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
+        new_args_from_connector != nullptr ? new_args_from_connector
+                                           : args_with_authority,
+        &new_security_connector_arg, 1);
+    subchannel_security_connector.reset(DEBUG_LOCATION, "lb_channel_create");
+    if (new_args_from_connector != nullptr) {
+      grpc_channel_args_destroy(new_args_from_connector);
+    }
     grpc_channel_args_destroy(args_with_authority);
-    return nullptr;
+    return new_args;
   }
-  grpc_arg new_security_connector_arg =
-      grpc_security_connector_to_arg(subchannel_security_connector.get());
+};
 
-  grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
-      new_args_from_connector != nullptr ? new_args_from_connector
-                                         : args_with_authority,
-      &new_security_connector_arg, 1);
+}  // namespace grpc_core
 
-  subchannel_security_connector.reset(DEBUG_LOCATION, "lb_channel_create");
-  if (new_args_from_connector != nullptr) {
-    grpc_channel_args_destroy(new_args_from_connector);
-  }
-  grpc_channel_args_destroy(args_with_authority);
-  grpc_subchannel_args* final_sc_args =
-      static_cast<grpc_subchannel_args*>(gpr_malloc(sizeof(*final_sc_args)));
-  memcpy(final_sc_args, args, sizeof(*args));
-  final_sc_args->args = new_args;
-  return final_sc_args;
-}
+namespace {
 
-static grpc_subchannel* client_channel_factory_create_subchannel(
-    grpc_client_channel_factory* cc_factory, const grpc_subchannel_args* args) {
-  grpc_subchannel_args* subchannel_args =
-      get_secure_naming_subchannel_args(args);
-  if (subchannel_args == nullptr) {
-    gpr_log(
-        GPR_ERROR,
-        "Failed to create subchannel arguments during subchannel creation.");
-    return nullptr;
-  }
-  grpc_connector* connector = grpc_chttp2_connector_create();
-  grpc_subchannel* s = grpc_subchannel_create(connector, subchannel_args);
-  grpc_connector_unref(connector);
-  grpc_channel_args_destroy(
-      const_cast<grpc_channel_args*>(subchannel_args->args));
-  gpr_free(subchannel_args);
-  return s;
-}
+grpc_core::Chttp2SecureClientChannelFactory* g_factory;
+gpr_once g_factory_once = GPR_ONCE_INIT;
 
-static grpc_channel* client_channel_factory_create_channel(
-    grpc_client_channel_factory* cc_factory, const char* target,
-    grpc_client_channel_type type, const grpc_channel_args* args) {
-  if (target == nullptr) {
-    gpr_log(GPR_ERROR, "cannot create channel with NULL target name");
-    return nullptr;
-  }
-  // Add channel arg containing the server URI.
-  grpc_core::UniquePtr<char> canonical_target =
-      grpc_core::ResolverRegistry::AddDefaultPrefixIfNeeded(target);
-  grpc_arg arg = grpc_channel_arg_string_create((char*)GRPC_ARG_SERVER_URI,
-                                                canonical_target.get());
-  const char* to_remove[] = {GRPC_ARG_SERVER_URI};
-  grpc_channel_args* new_args =
-      grpc_channel_args_copy_and_add_and_remove(args, to_remove, 1, &arg, 1);
-  grpc_channel* channel =
-      grpc_channel_create(target, new_args, GRPC_CLIENT_CHANNEL, nullptr);
-  grpc_channel_args_destroy(new_args);
-  return channel;
+void FactoryInit() {
+  g_factory = grpc_core::New<grpc_core::Chttp2SecureClientChannelFactory>();
 }
 
-static const grpc_client_channel_factory_vtable client_channel_factory_vtable =
-    {client_channel_factory_ref, client_channel_factory_unref,
-     client_channel_factory_create_subchannel,
-     client_channel_factory_create_channel};
-
-static grpc_client_channel_factory client_channel_factory = {
-    &client_channel_factory_vtable};
+}  // namespace
 
 // Create a secure client channel:
 //   Asynchronously: - resolve target
@@ -210,15 +201,15 @@ grpc_channel* grpc_secure_channel_create(grpc_channel_credentials* creds,
   if (creds != nullptr) {
     // Add channel args containing the client channel factory and channel
     // credentials.
+    gpr_once_init(&g_factory_once, FactoryInit);
     grpc_arg args_to_add[] = {
-        grpc_client_channel_factory_create_channel_arg(&client_channel_factory),
+        grpc_core::ClientChannelFactory::CreateChannelArg(g_factory),
         grpc_channel_credentials_to_arg(creds)};
     grpc_channel_args* new_args = grpc_channel_args_copy_and_add(
         args, args_to_add, GPR_ARRAY_SIZE(args_to_add));
+    new_args = creds->update_arguments(new_args);
     // Create channel.
-    channel = client_channel_factory_create_channel(
-        &client_channel_factory, target, GRPC_CLIENT_CHANNEL_TYPE_REGULAR,
-        new_args);
+    channel = g_factory->CreateChannel(target, new_args);
     // Clean up.
     grpc_channel_args_destroy(new_args);
   }

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

@@ -20,12 +20,12 @@
 
 #include "src/core/ext/transport/chttp2/server/chttp2_server.h"
 
-#include <grpc/grpc.h>
-
 #include <inttypes.h>
 #include <limits.h>
 #include <string.h>
 
+#include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>
@@ -54,7 +54,7 @@ typedef struct {
   bool shutdown;
   grpc_closure tcp_server_shutdown_complete;
   grpc_closure* server_destroy_listener_done;
-  grpc_handshake_manager* pending_handshake_mgrs;
+  grpc_core::HandshakeManager* pending_handshake_mgrs;
   grpc_core::RefCountedPtr<grpc_core::channelz::ListenSocketNode>
       channelz_listen_socket;
 } server_state;
@@ -64,7 +64,7 @@ typedef struct {
   server_state* svr_state;
   grpc_pollset* accepting_pollset;
   grpc_tcp_server_acceptor* acceptor;
-  grpc_handshake_manager* handshake_mgr;
+  grpc_core::RefCountedPtr<grpc_core::HandshakeManager> handshake_mgr;
   // State for enforcing handshake timeout on receiving HTTP/2 settings.
   grpc_chttp2_transport* transport;
   grpc_millis deadline;
@@ -112,7 +112,7 @@ static void on_receive_settings(void* arg, grpc_error* error) {
 }
 
 static void on_handshake_done(void* arg, grpc_error* error) {
-  grpc_handshaker_args* args = static_cast<grpc_handshaker_args*>(arg);
+  auto* args = static_cast<grpc_core::HandshakerArgs*>(arg);
   server_connection_state* connection_state =
       static_cast<server_connection_state*>(args->user_data);
   gpr_mu_lock(&connection_state->svr_state->mu);
@@ -175,11 +175,10 @@ static void on_handshake_done(void* arg, grpc_error* error) {
       }
     }
   }
-  grpc_handshake_manager_pending_list_remove(
-      &connection_state->svr_state->pending_handshake_mgrs,
-      connection_state->handshake_mgr);
+  connection_state->handshake_mgr->RemoveFromPendingMgrList(
+      &connection_state->svr_state->pending_handshake_mgrs);
   gpr_mu_unlock(&connection_state->svr_state->mu);
-  grpc_handshake_manager_destroy(connection_state->handshake_mgr);
+  connection_state->handshake_mgr.reset();
   gpr_free(connection_state->acceptor);
   grpc_tcp_server_unref(connection_state->svr_state->tcp_server);
   server_connection_state_unref(connection_state);
@@ -211,9 +210,8 @@ static void on_accept(void* arg, grpc_endpoint* tcp,
     gpr_free(acceptor);
     return;
   }
-  grpc_handshake_manager* handshake_mgr = grpc_handshake_manager_create();
-  grpc_handshake_manager_pending_list_add(&state->pending_handshake_mgrs,
-                                          handshake_mgr);
+  auto handshake_mgr = grpc_core::MakeRefCounted<grpc_core::HandshakeManager>();
+  handshake_mgr->AddToPendingMgrList(&state->pending_handshake_mgrs);
   grpc_tcp_server_ref(state->tcp_server);
   gpr_mu_unlock(&state->mu);
   server_connection_state* connection_state =
@@ -227,19 +225,19 @@ static void on_accept(void* arg, grpc_endpoint* tcp,
   connection_state->interested_parties = grpc_pollset_set_create();
   grpc_pollset_set_add_pollset(connection_state->interested_parties,
                                connection_state->accepting_pollset);
-  grpc_handshakers_add(HANDSHAKER_SERVER, state->args,
-                       connection_state->interested_parties,
-                       connection_state->handshake_mgr);
+  grpc_core::HandshakerRegistry::AddHandshakers(
+      grpc_core::HANDSHAKER_SERVER, state->args,
+      connection_state->interested_parties,
+      connection_state->handshake_mgr.get());
   const grpc_arg* timeout_arg =
       grpc_channel_args_find(state->args, GRPC_ARG_SERVER_HANDSHAKE_TIMEOUT_MS);
   connection_state->deadline =
       grpc_core::ExecCtx::Get()->Now() +
       grpc_channel_arg_get_integer(timeout_arg,
                                    {120 * GPR_MS_PER_SEC, 1, INT_MAX});
-  grpc_handshake_manager_do_handshake(connection_state->handshake_mgr, tcp,
-                                      state->args, connection_state->deadline,
-                                      acceptor, on_handshake_done,
-                                      connection_state);
+  connection_state->handshake_mgr->DoHandshake(
+      tcp, state->args, connection_state->deadline, acceptor, on_handshake_done,
+      connection_state);
 }
 
 /* Server callback: start listening on our ports */
@@ -260,8 +258,9 @@ static void tcp_server_shutdown_complete(void* arg, grpc_error* error) {
   gpr_mu_lock(&state->mu);
   grpc_closure* destroy_done = state->server_destroy_listener_done;
   GPR_ASSERT(state->shutdown);
-  grpc_handshake_manager_pending_list_shutdown_all(
-      state->pending_handshake_mgrs, GRPC_ERROR_REF(error));
+  if (state->pending_handshake_mgrs != nullptr) {
+    state->pending_handshake_mgrs->ShutdownAllPending(GRPC_ERROR_REF(error));
+  }
   state->channelz_listen_socket.reset();
   gpr_mu_unlock(&state->mu);
   // Flush queued work before destroying handshaker factory, since that
@@ -290,6 +289,50 @@ static void server_destroy_listener(grpc_server* server, void* arg,
   grpc_tcp_server_unref(tcp_server);
 }
 
+static grpc_error* chttp2_server_add_acceptor(grpc_server* server,
+                                              const char* name,
+                                              grpc_channel_args* args) {
+  grpc_tcp_server* tcp_server = nullptr;
+  grpc_error* err = GRPC_ERROR_NONE;
+  server_state* state = nullptr;
+  const grpc_arg* arg = nullptr;
+  grpc_core::TcpServerFdHandler** arg_val = nullptr;
+  state = static_cast<server_state*>(gpr_zalloc(sizeof(*state)));
+  GRPC_CLOSURE_INIT(&state->tcp_server_shutdown_complete,
+                    tcp_server_shutdown_complete, state,
+                    grpc_schedule_on_exec_ctx);
+  err = grpc_tcp_server_create(&state->tcp_server_shutdown_complete, args,
+                               &tcp_server);
+  if (err != GRPC_ERROR_NONE) {
+    goto error;
+  }
+  state->server = server;
+  state->tcp_server = tcp_server;
+  state->args = args;
+  state->shutdown = true;
+  gpr_mu_init(&state->mu);
+  // TODO(yangg) channelz
+  arg = grpc_channel_args_find(args, name);
+  GPR_ASSERT(arg->type == GRPC_ARG_POINTER);
+  arg_val = static_cast<grpc_core::TcpServerFdHandler**>(arg->value.pointer.p);
+  *arg_val = grpc_tcp_server_create_fd_handler(tcp_server);
+
+  grpc_server_add_listener(server, state, server_start_listener,
+                           server_destroy_listener, /* socket_uuid */ 0);
+  return err;
+
+/* Error path: cleanup and return */
+error:
+  GPR_ASSERT(err != GRPC_ERROR_NONE);
+  if (tcp_server) {
+    grpc_tcp_server_unref(tcp_server);
+  } else {
+    grpc_channel_args_destroy(args);
+    gpr_free(state);
+  }
+  return err;
+}
+
 grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
                                         grpc_channel_args* args,
                                         int* port_num) {
@@ -307,6 +350,10 @@ grpc_error* grpc_chttp2_server_add_port(grpc_server* server, const char* addr,
 
   *port_num = -1;
 
+  if (strncmp(addr, "external:", 9) == 0) {
+    return chttp2_server_add_acceptor(server, addr, args);
+  }
+
   /* resolve address */
   err = grpc_blocking_resolve_address(addr, "https", &resolved);
   if (err != GRPC_ERROR_NONE) {

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

@@ -51,7 +51,7 @@ static uint8_t decode_table[] = {
 
 static const uint8_t tail_xtra[4] = {0, 0, 1, 2};
 
-static bool input_is_valid(uint8_t* input_ptr, size_t length) {
+static bool input_is_valid(const uint8_t* input_ptr, size_t length) {
   size_t i;
 
   for (i = 0; i < length; ++i) {
@@ -158,7 +158,7 @@ bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx) {
   return true;
 }
 
-grpc_slice grpc_chttp2_base64_decode(grpc_slice input) {
+grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input) {
   size_t input_length = GRPC_SLICE_LENGTH(input);
   size_t output_length = input_length / 4 * 3;
   struct grpc_base64_decode_context ctx;
@@ -174,7 +174,7 @@ grpc_slice grpc_chttp2_base64_decode(grpc_slice input) {
   }
 
   if (input_length > 0) {
-    uint8_t* input_end = GRPC_SLICE_END_PTR(input);
+    const uint8_t* input_end = GRPC_SLICE_END_PTR(input);
     if (*(--input_end) == '=') {
       output_length--;
       if (*(--input_end) == '=') {
@@ -202,7 +202,7 @@ grpc_slice grpc_chttp2_base64_decode(grpc_slice input) {
   return output;
 }
 
-grpc_slice grpc_chttp2_base64_decode_with_length(grpc_slice input,
+grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
                                                  size_t output_length) {
   size_t input_length = GRPC_SLICE_LENGTH(input);
   grpc_slice output = GRPC_SLICE_MALLOC(output_length);

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

@@ -26,8 +26,8 @@
 
 struct grpc_base64_decode_context {
   /* input/output: */
-  uint8_t* input_cur;
-  uint8_t* input_end;
+  const uint8_t* input_cur;
+  const uint8_t* input_end;
   uint8_t* output_cur;
   uint8_t* output_end;
   /* Indicate if the decoder should handle the tail of input data*/
@@ -42,12 +42,12 @@ bool grpc_base64_decode_partial(struct grpc_base64_decode_context* ctx);
 
 /* base64 decode a slice with pad chars. Returns a new slice, does not take
    ownership of the input. Returns an empty slice if decoding is failed. */
-grpc_slice grpc_chttp2_base64_decode(grpc_slice input);
+grpc_slice grpc_chttp2_base64_decode(const grpc_slice& input);
 
 /* base64 decode a slice without pad chars, data length is needed. Returns a new
    slice, does not take ownership of the input. Returns an empty slice if
    decoding is failed. */
-grpc_slice grpc_chttp2_base64_decode_with_length(grpc_slice input,
+grpc_slice grpc_chttp2_base64_decode_with_length(const grpc_slice& input,
                                                  size_t output_length);
 
 /* Infer the length of decoded data from encoded data. */

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

@@ -48,13 +48,13 @@ static const b64_huff_sym huff_alphabet[64] = {
 
 static const uint8_t tail_xtra[3] = {0, 2, 3};
 
-grpc_slice grpc_chttp2_base64_encode(grpc_slice input) {
+grpc_slice grpc_chttp2_base64_encode(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;
   size_t output_length = input_triplets * 4 + tail_xtra[tail_case];
   grpc_slice output = GRPC_SLICE_MALLOC(output_length);
-  uint8_t* in = GRPC_SLICE_START_PTR(input);
+  const uint8_t* in = GRPC_SLICE_START_PTR(input);
   char* out = reinterpret_cast<char*> GRPC_SLICE_START_PTR(output);
   size_t i;
 
@@ -92,9 +92,9 @@ grpc_slice grpc_chttp2_base64_encode(grpc_slice input) {
   return output;
 }
 
-grpc_slice grpc_chttp2_huffman_compress(grpc_slice input) {
+grpc_slice grpc_chttp2_huffman_compress(const grpc_slice& input) {
   size_t nbits;
-  uint8_t* in;
+  const uint8_t* in;
   uint8_t* out;
   grpc_slice output;
   uint32_t temp = 0;
@@ -166,7 +166,8 @@ static void enc_add1(huff_out* out, uint8_t a) {
   enc_flush_some(out);
 }
 
-grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(grpc_slice input) {
+grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
+    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;
@@ -174,7 +175,7 @@ grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(grpc_slice input) {
   size_t max_output_bits = 11 * output_syms;
   size_t max_output_length = max_output_bits / 8 + (max_output_bits % 8 != 0);
   grpc_slice output = GRPC_SLICE_MALLOC(max_output_length);
-  uint8_t* in = GRPC_SLICE_START_PTR(input);
+  const uint8_t* in = GRPC_SLICE_START_PTR(input);
   uint8_t* start_out = GRPC_SLICE_START_PTR(output);
   huff_out out;
   size_t i;

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

@@ -25,17 +25,18 @@
 
 /* base64 encode a slice. Returns a new slice, does not take ownership of the
    input */
-grpc_slice grpc_chttp2_base64_encode(grpc_slice input);
+grpc_slice grpc_chttp2_base64_encode(const grpc_slice& input);
 
 /* Compress a slice with the static huffman encoder detailed in the hpack
    standard. Returns a new slice, does not take ownership of the input */
-grpc_slice grpc_chttp2_huffman_compress(grpc_slice input);
+grpc_slice grpc_chttp2_huffman_compress(const grpc_slice& input);
 
 /* equivalent to:
    grpc_slice x = grpc_chttp2_base64_encode(input);
    grpc_slice y = grpc_chttp2_huffman_compress(x);
    grpc_slice_unref_internal( x);
    return y; */
-grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(grpc_slice input);
+grpc_slice grpc_chttp2_base64_encode_and_huffman_compress(
+    const grpc_slice& input);
 
 #endif /* GRPC_CORE_EXT_TRANSPORT_CHTTP2_TRANSPORT_BIN_ENCODER_H */

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

@@ -20,16 +20,18 @@
 
 #include "src/core/ext/transport/chttp2/transport/chttp2_transport.h"
 #include "src/core/lib/debug/trace.h"
-#include "src/core/lib/gpr/env.h"
+#include "src/core/lib/gprpp/global_config.h"
 #include "src/core/lib/transport/metadata.h"
 
+GPR_GLOBAL_CONFIG_DEFINE_BOOL(
+    grpc_experimental_disable_flow_control, false,
+    "If set, flow control will be effectively disabled. Max out all values and "
+    "assume the remote peer does the same. Thus we can ignore any flow control "
+    "bookkeeping, error checking, and decision making");
+
 void grpc_chttp2_plugin_init(void) {
-  g_flow_control_enabled = true;
-  char* env_variable = gpr_getenv("GRPC_EXPERIMENTAL_DISABLE_FLOW_CONTROL");
-  if (env_variable != nullptr) {
-    g_flow_control_enabled = false;
-    gpr_free(env_variable);
-  }
+  g_flow_control_enabled =
+      !GPR_GLOBAL_CONFIG_GET(grpc_experimental_disable_flow_control);
 }
 
 void grpc_chttp2_plugin_shutdown(void) {}