diff --git a/build.yaml b/build.yaml
index fdc273e4dab..510b366b613 100644
--- a/build.yaml
+++ b/build.yaml
@@ -1233,7 +1233,6 @@ libs:
   src:
   - test/cpp/interop/server_helper.cc
   deps:
-  - grpc++_test_util
   - grpc_test_util
   - grpc++
   - grpc
diff --git a/test/cpp/end2end/async_end2end_test.cc b/test/cpp/end2end/async_end2end_test.cc
index 2ce3f2f7bd9..8e385d100c1 100644
--- a/test/cpp/end2end/async_end2end_test.cc
+++ b/test/cpp/end2end/async_end2end_test.cc
@@ -254,8 +254,7 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> {
 
     // Setup server
     ServerBuilder builder;
-    auto server_creds = GetCredentialsProvider()->GetServerCredentials(
-        GetParam().credentials_type);
+    auto server_creds = GetServerCredentials(GetParam().credentials_type);
     builder.AddListeningPort(server_address_.str(), server_creds);
     builder.RegisterService(&service_);
     cq_ = builder.AddCompletionQueue();
@@ -284,8 +283,8 @@ class AsyncEnd2endTest : public ::testing::TestWithParam<TestScenario> {
 
   void ResetStub() {
     ChannelArguments args;
-    auto channel_creds = GetCredentialsProvider()->GetChannelCredentials(
-        GetParam().credentials_type, &args);
+    auto channel_creds =
+        GetChannelCredentials(GetParam().credentials_type, &args);
     std::shared_ptr<Channel> channel =
         CreateCustomChannel(server_address_.str(), channel_creds, args);
     stub_ = grpc::testing::EchoTestService::NewStub(channel);
@@ -893,8 +892,8 @@ TEST_P(AsyncEnd2endTest, ServerCheckDone) {
 
 TEST_P(AsyncEnd2endTest, UnimplementedRpc) {
   ChannelArguments args;
-  auto channel_creds = GetCredentialsProvider()->GetChannelCredentials(
-      GetParam().credentials_type, &args);
+  auto channel_creds =
+      GetChannelCredentials(GetParam().credentials_type, &args);
   std::shared_ptr<Channel> channel =
       CreateCustomChannel(server_address_.str(), channel_creds, args);
   std::unique_ptr<grpc::testing::UnimplementedEchoService::Stub> stub;
@@ -1405,15 +1404,11 @@ std::vector<TestScenario> CreateTestScenarios(bool test_disable_blocking,
   std::vector<grpc::string> credentials_types;
   std::vector<grpc::string> messages;
 
-  if (GetCredentialsProvider()->GetChannelCredentials(kInsecureCredentialsType,
-                                                      nullptr) != nullptr) {
-    credentials_types.push_back(kInsecureCredentialsType);
-  }
-  auto sec_list = GetCredentialsProvider()->GetSecureCredentialsTypeList();
+  credentials_types.push_back(kInsecureCredentialsType);
+  auto sec_list = GetSecureCredentialsTypeList();
   for (auto sec = sec_list.begin(); sec != sec_list.end(); sec++) {
     credentials_types.push_back(*sec);
   }
-  GPR_ASSERT(!credentials_types.empty());
 
   messages.push_back("Hello");
   for (int sz = 1; sz < test_big_limit; sz *= 2) {
diff --git a/test/cpp/end2end/end2end_test.cc b/test/cpp/end2end/end2end_test.cc
index 1a1a94e87c7..9bb892c694b 100644
--- a/test/cpp/end2end/end2end_test.cc
+++ b/test/cpp/end2end/end2end_test.cc
@@ -242,8 +242,7 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> {
     // Setup server
     ServerBuilder builder;
     ConfigureServerBuilder(&builder);
-    auto server_creds = GetCredentialsProvider()->GetServerCredentials(
-        GetParam().credentials_type);
+    auto server_creds = GetServerCredentials(GetParam().credentials_type);
     if (GetParam().credentials_type != kInsecureCredentialsType) {
       server_creds->SetAuthMetadataProcessor(processor);
     }
@@ -271,8 +270,8 @@ class End2endTest : public ::testing::TestWithParam<TestScenario> {
     }
     EXPECT_TRUE(is_server_started_);
     ChannelArguments args;
-    auto channel_creds = GetCredentialsProvider()->GetChannelCredentials(
-        GetParam().credentials_type, &args);
+    auto channel_creds =
+        GetChannelCredentials(GetParam().credentials_type, &args);
     if (!user_agent_prefix_.empty()) {
       args.SetUserAgentPrefix(user_agent_prefix_);
     }
@@ -1521,18 +1520,11 @@ std::vector<TestScenario> CreateTestScenarios(bool use_proxy,
   std::vector<TestScenario> scenarios;
   std::vector<grpc::string> credentials_types;
   if (test_secure) {
-    credentials_types =
-        GetCredentialsProvider()->GetSecureCredentialsTypeList();
+    credentials_types = GetSecureCredentialsTypeList();
   }
   if (test_insecure) {
-    // Only add insecure credentials type when it is registered with the
-    // provider. User may create providers that do not have insecure.
-    if (GetCredentialsProvider()->GetChannelCredentials(
-            kInsecureCredentialsType, nullptr) != nullptr) {
-      credentials_types.push_back(kInsecureCredentialsType);
-    }
+    credentials_types.push_back(kInsecureCredentialsType);
   }
-  GPR_ASSERT(!credentials_types.empty());
   for (auto it = credentials_types.begin(); it != credentials_types.end();
        ++it) {
     scenarios.emplace_back(false, *it);
@@ -1549,7 +1541,7 @@ INSTANTIATE_TEST_CASE_P(End2end, End2endTest,
 
 INSTANTIATE_TEST_CASE_P(End2endServerTryCancel, End2endServerTryCancelTest,
                         ::testing::ValuesIn(CreateTestScenarios(false, true,
-                                                                true)));
+                                                                false)));
 
 INSTANTIATE_TEST_CASE_P(ProxyEnd2end, ProxyEnd2endTest,
                         ::testing::ValuesIn(CreateTestScenarios(true, true,
diff --git a/test/cpp/interop/client.cc b/test/cpp/interop/client.cc
index 3265554444b..c58910abc3f 100644
--- a/test/cpp/interop/client.cc
+++ b/test/cpp/interop/client.cc
@@ -49,7 +49,6 @@
 #include "test/cpp/util/test_config.h"
 
 DEFINE_bool(use_tls, false, "Whether to use tls.");
-DEFINE_string(custom_credentials_type, "", "User provided credentials type.");
 DEFINE_bool(use_test_ca, false, "False to use SSL roots for google");
 DEFINE_int32(server_port, 0, "Server port.");
 DEFINE_string(server_host, "127.0.0.1", "Server host to connect to");
diff --git a/test/cpp/interop/client_helper.cc b/test/cpp/interop/client_helper.cc
index 91564e5dcef..c171969e147 100644
--- a/test/cpp/interop/client_helper.cc
+++ b/test/cpp/interop/client_helper.cc
@@ -50,10 +50,8 @@
 #include "src/cpp/client/secure_credentials.h"
 #include "test/core/security/oauth2_utils.h"
 #include "test/cpp/util/create_test_channel.h"
-#include "test/cpp/util/test_credentials_provider.h"
 
 DECLARE_bool(use_tls);
-DECLARE_string(custom_credentials_type);
 DECLARE_bool(use_test_ca);
 DECLARE_int32(server_port);
 DECLARE_string(server_host);
@@ -116,12 +114,8 @@ std::shared_ptr<Channel> CreateChannelForTestCase(
     creds = AccessTokenCredentials(raw_token);
     GPR_ASSERT(creds);
   }
-  if (FLAGS_custom_credentials_type.empty()) {
-    return CreateTestChannel(host_port, FLAGS_server_host_override,
-                             FLAGS_use_tls, !FLAGS_use_test_ca, creds);
-  } else {
-    return CreateTestChannel(host_port, FLAGS_custom_credentials_type, creds);
-  }
+  return CreateTestChannel(host_port, FLAGS_server_host_override, FLAGS_use_tls,
+                           !FLAGS_use_test_ca, creds);
 }
 
 }  // namespace testing
diff --git a/test/cpp/interop/interop_server.cc b/test/cpp/interop/interop_server.cc
index bc6dc074541..8b50ae8c05a 100644
--- a/test/cpp/interop/interop_server.cc
+++ b/test/cpp/interop/interop_server.cc
@@ -56,7 +56,6 @@
 #include "test/cpp/util/test_config.h"
 
 DEFINE_bool(use_tls, false, "Whether to use tls.");
-DEFINE_string(custom_credentials_type, "", "User provided credentials type.");
 DEFINE_int32(port, 0, "Server port.");
 DEFINE_int32(max_send_message_size, -1, "The maximum send message size.");
 
diff --git a/test/cpp/interop/server_helper.cc b/test/cpp/interop/server_helper.cc
index d395f50fa59..8b0b511bcb8 100644
--- a/test/cpp/interop/server_helper.cc
+++ b/test/cpp/interop/server_helper.cc
@@ -39,23 +39,23 @@
 #include <grpc++/security/server_credentials.h>
 
 #include "src/core/lib/surface/call_test_only.h"
-#include "test/cpp/util/test_credentials_provider.h"
+#include "test/core/end2end/data/ssl_test_data.h"
 
 DECLARE_bool(use_tls);
-DECLARE_string(custom_credentials_type);
 
 namespace grpc {
 namespace testing {
 
 std::shared_ptr<ServerCredentials> CreateInteropServerCredentials() {
-  if (!FLAGS_custom_credentials_type.empty()) {
-    return GetCredentialsProvider()->GetServerCredentials(
-        FLAGS_custom_credentials_type);
-  } else if (FLAGS_use_tls) {
-    return GetCredentialsProvider()->GetServerCredentials(kTlsCredentialsType);
+  if (FLAGS_use_tls) {
+    SslServerCredentialsOptions::PemKeyCertPair pkcp = {test_server1_key,
+                                                        test_server1_cert};
+    SslServerCredentialsOptions ssl_opts;
+    ssl_opts.pem_root_certs = "";
+    ssl_opts.pem_key_cert_pairs.push_back(pkcp);
+    return SslServerCredentials(ssl_opts);
   } else {
-    return GetCredentialsProvider()->GetServerCredentials(
-        kInsecureCredentialsType);
+    return InsecureServerCredentials();
   }
 }
 
diff --git a/test/cpp/interop/stress_test.cc b/test/cpp/interop/stress_test.cc
index af707d31905..fc35db5233a 100644
--- a/test/cpp/interop/stress_test.cc
+++ b/test/cpp/interop/stress_test.cc
@@ -147,7 +147,6 @@ DEFINE_bool(do_not_abort_on_transient_failures, true,
 // Options from client.cc (for compatibility with interop test).
 // TODO(sreek): Consolidate overlapping options
 DEFINE_bool(use_tls, false, "Whether to use tls.");
-DEFINE_string(custom_credentials_type, "", "User provided credentials type.");
 DEFINE_bool(use_test_ca, false, "False to use SSL roots for google");
 DEFINE_int32(server_port, 0, "Server port.");
 DEFINE_string(server_host, "127.0.0.1", "Server host to connect to");
diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc
index ad62e03490e..fe8b5d54235 100644
--- a/test/cpp/util/create_test_channel.cc
+++ b/test/cpp/util/create_test_channel.cc
@@ -35,37 +35,11 @@
 
 #include <grpc++/create_channel.h>
 #include <grpc++/security/credentials.h>
-#include <grpc/support/log.h>
 
-#include "test/cpp/util/test_credentials_provider.h"
+#include "test/core/end2end/data/ssl_test_data.h"
 
 namespace grpc {
 
-namespace {
-
-const char kProdTlsCredentialsType[] = "prod_ssl";
-
-class SslCredentialProvider : public testing::CredentialTypeProvider {
- public:
-  std::shared_ptr<ChannelCredentials> GetChannelCredentials(
-      grpc::ChannelArguments* args) override {
-    return SslCredentials(SslCredentialsOptions());
-  }
-  std::shared_ptr<ServerCredentials> GetServerCredentials() override {
-    return nullptr;
-  }
-};
-
-gpr_once g_once_init_add_prod_ssl_provider = GPR_ONCE_INIT;
-// Register ssl with non-test roots type to the credentials provider.
-void AddProdSslType() {
-  testing::GetCredentialsProvider()->AddSecureType(
-      kProdTlsCredentialsType, std::unique_ptr<testing::CredentialTypeProvider>(
-                                   new SslCredentialProvider));
-}
-
-}  // namespace
-
 // When ssl is enabled, if server is empty, override_hostname is used to
 // create channel. Otherwise, connect to server and override hostname if
 // override_hostname is provided.
@@ -87,22 +61,16 @@ std::shared_ptr<Channel> CreateTestChannel(
     const std::shared_ptr<CallCredentials>& creds,
     const ChannelArguments& args) {
   ChannelArguments channel_args(args);
-  std::shared_ptr<ChannelCredentials> channel_creds;
   if (enable_ssl) {
-    if (use_prod_roots) {
-      gpr_once_init(&g_once_init_add_prod_ssl_provider, &AddProdSslType);
-      channel_creds = testing::GetCredentialsProvider()->GetChannelCredentials(
-          kProdTlsCredentialsType, &channel_args);
-      if (!server.empty() && !override_hostname.empty()) {
-        channel_args.SetSslTargetNameOverride(override_hostname);
-      }
-    } else {
-      // override_hostname is discarded as the provider handles it.
-      channel_creds = testing::GetCredentialsProvider()->GetChannelCredentials(
-          testing::kTlsCredentialsType, &channel_args);
-    }
-    GPR_ASSERT(channel_creds != nullptr);
+    const char* roots_certs = use_prod_roots ? "" : test_root_cert;
+    SslCredentialsOptions ssl_opts = {roots_certs, "", ""};
+
+    std::shared_ptr<ChannelCredentials> channel_creds =
+        SslCredentials(ssl_opts);
 
+    if (!server.empty() && !override_hostname.empty()) {
+      channel_args.SetSslTargetNameOverride(override_hostname);
+    }
     const grpc::string& connect_to =
         server.empty() ? override_hostname : server;
     if (creds.get()) {
@@ -135,18 +103,4 @@ std::shared_ptr<Channel> CreateTestChannel(const grpc::string& server,
   return CreateTestChannel(server, "foo.test.google.fr", enable_ssl, false);
 }
 
-std::shared_ptr<Channel> CreateTestChannel(
-    const grpc::string& server, const grpc::string& credential_type,
-    const std::shared_ptr<CallCredentials>& creds) {
-  ChannelArguments channel_args;
-  std::shared_ptr<ChannelCredentials> channel_creds =
-      testing::GetCredentialsProvider()->GetChannelCredentials(credential_type,
-                                                               &channel_args);
-  GPR_ASSERT(channel_creds != nullptr);
-  if (creds.get()) {
-    channel_creds = CompositeChannelCredentials(channel_creds, creds);
-  }
-  return CreateCustomChannel(server, channel_creds, channel_args);
-}
-
 }  // namespace grpc
diff --git a/test/cpp/util/create_test_channel.h b/test/cpp/util/create_test_channel.h
index ce71a97edbb..4ff666dc1bc 100644
--- a/test/cpp/util/create_test_channel.h
+++ b/test/cpp/util/create_test_channel.h
@@ -59,10 +59,6 @@ std::shared_ptr<Channel> CreateTestChannel(
     const std::shared_ptr<CallCredentials>& creds,
     const ChannelArguments& args);
 
-std::shared_ptr<Channel> CreateTestChannel(
-    const grpc::string& server, const grpc::string& credential_type,
-    const std::shared_ptr<CallCredentials>& creds);
-
 }  // namespace grpc
 
 #endif  // GRPC_TEST_CPP_UTIL_CREATE_TEST_CHANNEL_H
diff --git a/test/cpp/util/test_credentials_provider.cc b/test/cpp/util/test_credentials_provider.cc
index 909b02a7019..0456b966671 100644
--- a/test/cpp/util/test_credentials_provider.cc
+++ b/test/cpp/util/test_credentials_provider.cc
@@ -43,9 +43,25 @@
 #include "test/core/end2end/data/ssl_test_data.h"
 
 namespace grpc {
-namespace testing {
 namespace {
 
+using grpc::testing::CredentialTypeProvider;
+
+// Provide test credentials. Thread-safe.
+class CredentialsProvider {
+ public:
+  virtual ~CredentialsProvider() {}
+
+  virtual void AddSecureType(
+      const grpc::string& type,
+      std::unique_ptr<CredentialTypeProvider> type_provider) = 0;
+  virtual std::shared_ptr<ChannelCredentials> GetChannelCredentials(
+      const grpc::string& type, ChannelArguments* args) = 0;
+  virtual std::shared_ptr<ServerCredentials> GetServerCredentials(
+      const grpc::string& type) = 0;
+  virtual std::vector<grpc::string> GetSecureCredentialsTypeList() = 0;
+};
+
 class DefaultCredentialsProvider : public CredentialsProvider {
  public:
   ~DefaultCredentialsProvider() override {}
@@ -129,21 +145,37 @@ class DefaultCredentialsProvider : public CredentialsProvider {
       added_secure_type_providers_;
 };
 
+gpr_once g_once_init_provider = GPR_ONCE_INIT;
 CredentialsProvider* g_provider = nullptr;
 
-}  // namespace
+void CreateDefaultProvider() { g_provider = new DefaultCredentialsProvider; }
 
-CredentialsProvider* GetCredentialsProvider() {
-  if (g_provider == nullptr) {
-    g_provider = new DefaultCredentialsProvider;
-  }
+CredentialsProvider* GetProvider() {
+  gpr_once_init(&g_once_init_provider, &CreateDefaultProvider);
   return g_provider;
 }
 
-void SetCredentialsProvider(CredentialsProvider* provider) {
-  // For now, forbids overriding provider.
-  GPR_ASSERT(g_provider == nullptr);
-  g_provider = provider;
+}  // namespace
+
+namespace testing {
+
+void AddSecureType(const grpc::string& type,
+                   std::unique_ptr<CredentialTypeProvider> type_provider) {
+  GetProvider()->AddSecureType(type, std::move(type_provider));
+}
+
+std::shared_ptr<ChannelCredentials> GetChannelCredentials(
+    const grpc::string& type, ChannelArguments* args) {
+  return GetProvider()->GetChannelCredentials(type, args);
+}
+
+std::shared_ptr<ServerCredentials> GetServerCredentials(
+    const grpc::string& type) {
+  return GetProvider()->GetServerCredentials(type);
+}
+
+std::vector<grpc::string> GetSecureCredentialsTypeList() {
+  return GetProvider()->GetSecureCredentialsTypeList();
 }
 
 }  // namespace testing
diff --git a/test/cpp/util/test_credentials_provider.h b/test/cpp/util/test_credentials_provider.h
index 0bc52ebe4df..1fb311e556e 100644
--- a/test/cpp/util/test_credentials_provider.h
+++ b/test/cpp/util/test_credentials_provider.h
@@ -59,39 +59,23 @@ class CredentialTypeProvider {
   virtual std::shared_ptr<ServerCredentials> GetServerCredentials() = 0;
 };
 
-// Provide test credentials. Thread-safe.
-class CredentialsProvider {
- public:
-  virtual ~CredentialsProvider() {}
-
-  // Add a secure type in addition to the defaults. The default provider has
-  // (kInsecureCredentialsType, kTlsCredentialsType).
-  virtual void AddSecureType(
-      const grpc::string& type,
-      std::unique_ptr<CredentialTypeProvider> type_provider) = 0;
-
-  // Provide channel credentials according to the given type. Alter the channel
-  // arguments if needed. Return nullptr if type is not registered.
-  virtual std::shared_ptr<ChannelCredentials> GetChannelCredentials(
-      const grpc::string& type, ChannelArguments* args) = 0;
-
-  // Provide server credentials according to the given type.
-  // Return nullptr if type is not registered.
-  virtual std::shared_ptr<ServerCredentials> GetServerCredentials(
-      const grpc::string& type) = 0;
-
-  // Provide a list of secure credentials type.
-  virtual std::vector<grpc::string> GetSecureCredentialsTypeList() = 0;
-};
-
-// Get the current provider. Create a default one if not set.
-// Not thread-safe.
-CredentialsProvider* GetCredentialsProvider();
-
-// Set the global provider. Takes ownership. The previous set provider will be
-// destroyed.
-// Not thread-safe.
-void SetCredentialsProvider(CredentialsProvider* provider);
+// Add a secure type in addition to the defaults above
+// (kInsecureCredentialsType, kTlsCredentialsType) that can be returned from the
+// functions below.
+void AddSecureType(const grpc::string& type,
+                   std::unique_ptr<CredentialTypeProvider> type_provider);
+
+// Provide channel credentials according to the given type. Alter the channel
+// arguments if needed.
+std::shared_ptr<ChannelCredentials> GetChannelCredentials(
+    const grpc::string& type, ChannelArguments* args);
+
+// Provide server credentials according to the given type.
+std::shared_ptr<ServerCredentials> GetServerCredentials(
+    const grpc::string& type);
+
+// Provide a list of secure credentials type.
+std::vector<grpc::string> GetSecureCredentialsTypeList();
 
 }  // namespace testing
 }  // namespace grpc
diff --git a/tools/run_tests/sources_and_headers.json b/tools/run_tests/sources_and_headers.json
index a5700d26c34..abdcfe501b2 100644
--- a/tools/run_tests/sources_and_headers.json
+++ b/tools/run_tests/sources_and_headers.json
@@ -5447,7 +5447,6 @@
       "gpr", 
       "grpc", 
       "grpc++", 
-      "grpc++_test_util", 
       "grpc_test_util"
     ], 
     "headers": [
diff --git a/vsprojects/vcxproj/interop_server_helper/interop_server_helper.vcxproj b/vsprojects/vcxproj/interop_server_helper/interop_server_helper.vcxproj
index 377cadc1a1e..4c99988a34c 100644
--- a/vsprojects/vcxproj/interop_server_helper/interop_server_helper.vcxproj
+++ b/vsprojects/vcxproj/interop_server_helper/interop_server_helper.vcxproj
@@ -154,9 +154,6 @@
     </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ProjectReference Include="$(SolutionDir)\..\vsprojects\vcxproj\.\grpc++_test_util\grpc++_test_util.vcxproj">
-      <Project>{0BE77741-552A-929B-A497-4EF7ECE17A64}</Project>
-    </ProjectReference>
     <ProjectReference Include="$(SolutionDir)\..\vsprojects\vcxproj\.\grpc_test_util\grpc_test_util.vcxproj">
       <Project>{17BCAFC0-5FDC-4C94-AEB9-95F3E220614B}</Project>
     </ProjectReference>