func decompress(compressor encoding.Compressor, d mem.BufferSlice, dc Decompressor, maxReceiveMessageSize int, pool mem.BufferPool) (mem.BufferSlice, error) {
    if dc != nil {
        return customDecompress(dc, d, maxReceiveMessageSize)
    }
    if compressor != nil {
        return standardDecompress(compressor, d, maxReceiveMessageSize, pool)
    }
    return nil, status.Errorf(codes.Internal, "grpc: no decompressor available for compressed payload")
}

func customDecompress(dc Decompressor, d mem.BufferSlice, maxReceiveMessageSize int) (mem.BufferSlice, error) {
    uncompressed, err := dc.Do(d.Reader())
    if err != nil {
        return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the received message: %v", err)
    }
    if len(uncompressed) > maxReceiveMessageSize {
        return nil, status.Errorf(codes.ResourceExhausted, "grpc: message after decompression larger than max (%d vs. %d)",
            len(uncompressed), maxReceiveMessageSize)
    }
    return mem.BufferSlice{mem.SliceBuffer(uncompressed)}, nil
}

func standardDecompress(compressor encoding.Compressor, d mem.BufferSlice, maxReceiveMessageSize int, pool mem.BufferPool) (mem.BufferSlice, error) {
    dcReader, err := compressor.Decompress(d.Reader())
    if err != nil {
        return nil, status.Errorf(codes.Internal, "grpc: failed to decompress the message: %v", err)
    }
    out, err := mem.ReadAll(io.LimitReader(dcReader, int64(maxReceiveMessageSize)), pool)
    if err != nil {
        out.Free()
        return nil, status.Errorf(codes.Internal, "grpc: failed to read decompressed data: %v", err)
    }
    if out.Len() == maxReceiveMessageSize && !atEOF(dcReader) {
        out.Free()
        return nil, status.Errorf(codes.ResourceExhausted, "grpc: received message after decompression larger than max %d", maxReceiveMessageSize)
    }
    return out, nil
}

func (es *endpointSharding) withChildLock(fn func()) {
    es.childMu.Lock()
    defer es.childMu.Unlock()
    fn()
}

func (es *endpointSharding) withStateLock(fn func()) {
    es.mu.Lock()
    defer es.mu.Unlock()
    fn()
}

func (es *endpointSharding) UpdateClientConnState(state balancer.ClientConnState) error {
    var ret error
    es.withChildLock(func() {
        es.inhibitChildUpdates.Store(true)
        defer func() {
            es.inhibitChildUpdates.Store(false)
        }()
        // Update and create new children.
        children := es.children.Load()
        newChildren := resolver.NewEndpointMap()
        for _, endpoint := range state.ResolverState.Endpoints {
            if _, ok := newChildren.Get(endpoint); ok {
                continue
            }
            var childBalancer *balancerWrapper
            if val, ok := children.Get(endpoint); ok {
                childBalancer = val.(*balancerWrapper)
                es.withStateLock(func() {
                    childBalancer.childState.Endpoint = endpoint
                })
            } else {
                childBalancer = &balancerWrapper{
                    childState: ChildState{Endpoint: endpoint},
                    ClientConn: es.cc,
                    es:         es,
                }
                childBalancer.childState.Balancer = childBalancer
                childBalancer.child = es.childBuilder(childBalancer, es.bOpts)
            }
            newChildren.Set(endpoint, childBalancer)
            if err := childBalancer.updateClientConnStateLocked(balancer.ClientConnState{
                BalancerConfig: state.BalancerConfig,
                ResolverState: resolver.State{
                    Endpoints:  []resolver.Endpoint{endpoint},
                    Attributes: state.ResolverState.Attributes,
                },
            }); err != nil && ret == nil {
                ret = err
            }
        }
        // Delete removed children.
        for _, e := range children.Keys() {
            if child, ok := newChildren.Get(e); !ok {
                child.(*balancerWrapper).closeLocked()
            }
        }
        es.children.Store(newChildren)
    })
    es.updateState()
    if newChildren := es.children.Load(); newChildren.Len() == 0 {
        return balancer.ErrBadResolverState
    }
    return ret
}

func (r *delegatingResolver) combineAddresses(proxyAddr resolver.Address, targetAddrs []resolver.Address) []resolver.Address {
	var addresses []resolver.Address
	for _, tAddr := range targetAddrs {
		addresses = append(addresses, proxyattributes.Set(proxyAddr, proxyattributes.Options{
			User:        r.proxyURL.User,
			ConnectAddr: tAddr.Addr,
		}))
	}
	return addresses
}

func (r *delegatingResolver) combineEndpoints(proxyAddrs []resolver.Address, endpoints []resolver.Endpoint) []resolver.Endpoint {
	var combined []resolver.Endpoint
	for _, ep := range endpoints {
		var addrs []resolver.Address
		for _, pAddr := range proxyAddrs {
			for _, tAddr := range ep.Addresses {
				addrs = append(addrs, proxyattributes.Set(pAddr, proxyattributes.Options{
					User:        r.proxyURL.User,
					ConnectAddr: tAddr.Addr,
				}))
			}
		}
		combined = append(combined, resolver.Endpoint{Addresses: addrs})
	}
	return combined
}

func (r *delegatingResolver) updateClientConnStateLocked() error {
	if r.targetResolverState == nil || r.proxyAddrs == nil {
		return nil
	}

	curState := *r.targetResolverState
	var proxyAddr resolver.Address
	if len(r.proxyAddrs) == 1 {
		proxyAddr = r.proxyAddrs[0]
	} else {
		proxyAddr = resolver.Address{Addr: r.proxyURL.Host}
	}

	curState.Addresses = r.combineAddresses(proxyAddr, curState.Addresses)
	curState.Endpoints = r.combineEndpoints(r.proxyAddrs, curState.Endpoints)
	return r.cc.UpdateState(curState)
}