Revert "Test credentials provider update"

4 files changed, 68 insertions, 102 deletions

diff --git a/test/cpp/util/create_test_channel.cc b/test/cpp/util/create_test_channel.cc
index ad62e03490..fe8b5d5423 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 ce71a97edb..4ff666dc1b 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 909b02a701..0456b96667 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 0bc52ebe4d..1fb311e556 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