Fix sanity_check and add a test

src/core/lib/channel/channel_args.cc

@@ -16,14 +16,14 @@
  *
  */
 
-#include <grpc/impl/codegen/grpc_types.h>
-#include <grpc/impl/codegen/log.h>
 #include <grpc/support/port_platform.h>
 
 #include <limits.h>
 #include <string.h>
 
 #include <grpc/grpc.h>
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/log.h>
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/string_util.h>

test/core/channel/channel_args_test.cc

@@ -16,13 +16,17 @@
  *
  */
 
+#include <grpc/impl/codegen/grpc_types.h>
+#include <grpc/impl/codegen/log.h>
 #include <string.h>
 
 #include <grpc/support/log.h>
 
 #include "src/core/lib/channel/channel_args.h"
+#include "src/core/lib/channel/channel_stack.h"
 #include "src/core/lib/gpr/useful.h"
 #include "src/core/lib/iomgr/exec_ctx.h"
+#include "src/core/lib/surface/channel.h"
 #include "test/core/util/test_config.h"
 
 static void test_create(void) {
@@ -111,6 +115,86 @@ static void test_channel_create_with_args(void) {
   grpc_channel_destroy(c);
 }
 
+grpc_channel_args* mutate_channel_args(const char* target,
+                                       grpc_channel_args* old_args,
+                                       grpc_channel_stack_type type) {
+  GPR_ASSERT(old_args != nullptr);
+  GPR_ASSERT(grpc_channel_args_find(old_args, "arg_int")->value.integer == 0);
+  GPR_ASSERT(strcmp(grpc_channel_args_find(old_args, "arg_str")->value.string,
+                    "arg_str_val") == 0);
+  GPR_ASSERT(
+      grpc_channel_args_find(old_args, "arg_pointer")->value.pointer.vtable ==
+      &fake_pointer_arg_vtable);
+
+  if (strcmp(target, "no_op_mutator") == 0) {
+    return old_args;
+  }
+
+  GPR_ASSERT(strcmp(target, "minimal_stack_mutator") == 0);
+  const char* args_to_remove[] = {"arg_int", "arg_str", "arg_pointer"};
+
+  grpc_arg no_deadline_filter_arg = grpc_channel_arg_integer_create(
+      const_cast<char*>(GRPC_ARG_MINIMAL_STACK), 1);
+  grpc_channel_args* new_args = nullptr;
+  new_args = grpc_channel_args_copy_and_add_and_remove(
+      old_args, args_to_remove, GPR_ARRAY_SIZE(args_to_remove),
+      &no_deadline_filter_arg, 1);
+  grpc_channel_args_destroy(old_args);
+  return new_args;
+}
+
+// Minimal stack should not have client_idle filter
+static bool channel_has_client_idle_filter(grpc_channel* c) {
+  grpc_channel_stack* stack = grpc_channel_get_channel_stack(c);
+  for (size_t i = 0; i < stack->count; i++) {
+    if (strcmp(grpc_channel_stack_element(stack, i)->filter->name,
+               "client_idle") == 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+static void test_channel_create_with_global_mutator(void) {
+  grpc_channel_args_set_client_channel_creation_mutator(mutate_channel_args);
+  // We also add some custom args to make sure the ownership is correct.
+  grpc_arg client_a[3];
+
+  // adds integer arg
+  client_a[0].type = GRPC_ARG_INTEGER;
+  client_a[0].key = const_cast<char*>("arg_int");
+  client_a[0].value.integer = 0;
+
+  // adds const str arg
+  client_a[1].type = GRPC_ARG_STRING;
+  client_a[1].key = const_cast<char*>("arg_str");
+  client_a[1].value.string = const_cast<char*>("arg_str_val");
+
+  // allocated and adds custom pointer arg
+  fake_class* fc = static_cast<fake_class*>(gpr_malloc(sizeof(fake_class)));
+  fc->foo = 42;
+  client_a[2].type = GRPC_ARG_POINTER;
+  client_a[2].key = const_cast<char*>("arg_pointer");
+  client_a[2].value.pointer.vtable = &fake_pointer_arg_vtable;
+  client_a[2].value.pointer.p = fc;
+
+  // creates channels
+  grpc_channel_args client_args = {GPR_ARRAY_SIZE(client_a), client_a};
+  grpc_channel* c =
+      grpc_insecure_channel_create("no_op_mutator", &client_args, nullptr);
+  GPR_ASSERT(channel_has_client_idle_filter(c));
+  grpc_channel_destroy(c);
+
+  c = grpc_insecure_channel_create("minimal_stack_mutator", &client_args,
+                                   nullptr);
+  GPR_ASSERT(channel_has_client_idle_filter(c) == false);
+  grpc_channel_destroy(c);
+
+  gpr_free(fc);
+  auto mutator = grpc_channel_args_get_client_channel_creation_mutator();
+  GPR_ASSERT(mutator == &mutate_channel_args);
+}
+
 static void test_server_create_with_args(void) {
   grpc_arg server_a[3];
 
@@ -146,6 +230,8 @@ int main(int argc, char** argv) {
   test_create();
   test_channel_create_with_args();
   test_server_create_with_args();
+  // This has to be the last test.
+  test_channel_create_with_global_mutator();
   grpc_shutdown();
   return 0;
 }