Fixed the names of the structures

credentials/tls/certprovider/store.go

@@ -26,7 +26,7 @@ import (
 
 // provStore is the global singleton certificate provider store.
 var provStore = &store{
-	providers: make(map[storeKey]*wrappedProvider),
+	providers: make(map[storeKey]*providerHolder),
 }
 
 // storeKey acts as the key to the map of providers maintained by the store. A
@@ -43,8 +43,8 @@ type storeKey struct {
 	opts BuildOptions
 }
 
-// wrappedProvider wraps a provider instance with a reference count.
-type wrappedProvider struct {
+// providerHolder store provider instance with a reference count.
+type providerHolder struct {
 	provider Provider
 	refCount int
 
@@ -54,24 +54,25 @@ type wrappedProvider struct {
 	store    *store
 }
 
-// wrappedProviderCloser wraps a provider instance with a reference count to avoid double
-// close still in use provider.
-type wrappedProviderCloser struct {
-	mu sync.RWMutex
-	wp *wrappedProvider
+// wrappedProvider wraps a provider instance with a reference count to avoid double
+// Close still in use provider.
+// After Close, all wrappedProvider methods will return a errProviderClosed error.
+type wrappedProvider struct {
+	mu     sync.RWMutex
+	holder *providerHolder
 }
 
 // store is a collection of provider instances, safe for concurrent access.
 type store struct {
 	mu        sync.Mutex
-	providers map[storeKey]*wrappedProvider
+	providers map[storeKey]*providerHolder
 }
 
 // Close overrides the Close method of the embedded provider. It releases the
 // reference held by the caller on the underlying provider and if the
 // provider's reference count reaches zero, it is removed from the store, and
 // its Close method is also invoked.
-func (wp *wrappedProvider) Close() {
+func (wp *providerHolder) Close() {
 	ps := wp.store
 	ps.mu.Lock()
 	defer ps.mu.Unlock()
@@ -85,25 +86,25 @@ func (wp *wrappedProvider) Close() {
 
 // Close overrides the Close method of the embedded provider to avoid release the
 // already released reference.
-func (w *wrappedProviderCloser) Close() {
+func (w *wrappedProvider) Close() {
 	w.mu.Lock()
 	defer w.mu.Unlock()
-	if wp := w.wp; wp != nil {
-		w.wp = nil
-		wp.Close()
+	if holder := w.holder; holder != nil {
+		w.holder = nil
+		holder.Close()
 	}
 }
 
 // KeyMaterial returns the key material sourced by the Provider.
 // Callers are expected to use the returned value as read-only.
-func (w *wrappedProviderCloser) KeyMaterial(ctx context.Context) (*KeyMaterial, error) {
+func (w *wrappedProvider) KeyMaterial(ctx context.Context) (*KeyMaterial, error) {
 	w.mu.RLock()
 	defer w.mu.RUnlock()
 
-	if w.wp == nil {
+	if w.holder == nil {
 		return nil, errProviderClosed
 	}
-	return w.wp.provider.KeyMaterial(ctx)
+	return w.holder.provider.KeyMaterial(ctx)
 }
 
 // BuildableConfig wraps parsed provider configuration and functionality to
@@ -141,23 +142,23 @@ func (bc *BuildableConfig) Build(opts BuildOptions) (Provider, error) {
 		config: string(bc.config),
 		opts:   opts,
 	}
-	if wp, ok := provStore.providers[sk]; ok {
-		wp.refCount++
-		return &wrappedProviderCloser{wp: wp}, nil
+	if holder, ok := provStore.providers[sk]; ok {
+		holder.refCount++
+		return &wrappedProvider{holder: holder}, nil
 	}
 
 	provider := bc.starter(opts)
 	if provider == nil {
 		return nil, fmt.Errorf("provider(%q, %q).Build(%v) failed", sk.name, sk.config, opts)
 	}
-	wp := &wrappedProvider{
+	holder := &providerHolder{
 		provider: provider,
 		refCount: 1,
 		storeKey: sk,
 		store:    provStore,
 	}
-	provStore.providers[sk] = wp
-	return &wrappedProviderCloser{wp: wp}, nil
+	provStore.providers[sk] = holder
+	return &wrappedProvider{holder: holder}, nil
 }
 
 // String returns the provider name and config as a colon separated string.