Cleanup HttpPipelineMessage and HttpClientOptions

sdk/appconfiguration/Azure.ApplicationModel.Configuration/src/AuthenticationPolicy.cs

@@ -41,11 +41,11 @@ private async Task ProcessAsync(HttpPipelineMessage message, bool async)
                     {
                         if (async)
                         {
-                            await message.Request.Content.WriteToAsync(contentHashStream, message.Cancellation);
+                            await message.Request.Content.WriteToAsync(contentHashStream, message.CancellationToken);
                         }
                         else
                         {
-                            message.Request.Content.WriteTo(contentHashStream, message.Cancellation);
+                            message.Request.Content.WriteTo(contentHashStream, message.CancellationToken);
                         }
                     }
                 }

sdk/core/Azure.Core/src/Pipeline/HttpClientTransport.cs

@@ -32,7 +32,7 @@ public HttpClientTransport(HttpClient client)
 
         public static readonly HttpClientTransport Shared = new HttpClientTransport();
 
-        public sealed override Request CreateRequest(IServiceProvider services)
+        public sealed override Request CreateRequest()
             => new PipelineRequest();
 
         public override void Process(HttpPipelineMessage message)
@@ -45,7 +45,7 @@ public sealed override async Task ProcessAsync(HttpPipelineMessage message)
         {
             using (HttpRequestMessage httpRequest = BuildRequestMessage(message))
             {
-                HttpResponseMessage responseMessage = await _client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, message.Cancellation)
+                HttpResponseMessage responseMessage = await _client.SendAsync(httpRequest, HttpCompletionOption.ResponseHeadersRead, message.CancellationToken)
                     .ConfigureAwait(false);
                 message.Response = new PipelineResponse(message.Request.ClientRequestId, responseMessage);
             }
@@ -69,7 +69,7 @@ private static HttpRequestMessage BuildRequestMessage(HttpPipelineMessage messag
             {
                 throw new InvalidOperationException("the request is not compatible with the transport");
             }
-            return pipelineRequest.BuildRequestMessage(message.Cancellation);
+            return pipelineRequest.BuildRequestMessage(message.CancellationToken);
         }
 
         internal static bool TryGetHeader(HttpHeaders headers, HttpContent content, string name, out string value)

sdk/core/Azure.Core/src/Pipeline/HttpPipeline.cs

@@ -17,9 +17,8 @@ public class HttpPipeline
         private readonly HttpPipelineTransport _transport;
         private readonly ResponseClassifier _responseClassifier;
         private readonly ReadOnlyMemory<HttpPipelinePolicy> _pipeline;
-        private readonly IServiceProvider _services;
 
-        public HttpPipeline(HttpPipelineTransport transport, HttpPipelinePolicy[] policies = null, ResponseClassifier responseClassifier = null, IServiceProvider services = null)
+        public HttpPipeline(HttpPipelineTransport transport, HttpPipelinePolicy[] policies = null, ResponseClassifier responseClassifier = null)
         {
             _transport = transport ?? throw new ArgumentNullException(nameof(transport));
             _responseClassifier = responseClassifier ?? new ResponseClassifier();
@@ -31,34 +30,29 @@ public HttpPipeline(HttpPipelineTransport transport, HttpPipelinePolicy[] polici
             policies.CopyTo(all, 0);
 
             _pipeline = all;
-            _services = services ?? HttpClientOptions.EmptyServiceProvider.Singleton;
         }
 
         public Request CreateRequest()
-            => _transport.CreateRequest(_services);
+            => _transport.CreateRequest();
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public async Task<Response> SendRequestAsync(Request request, CancellationToken cancellationToken)
         {
-            using (var message = new HttpPipelineMessage(cancellationToken))
-            {
-                message.Request = request;
-                message.ResponseClassifier = _responseClassifier;
-                await _pipeline.Span[0].ProcessAsync(message, _pipeline.Slice(1)).ConfigureAwait(false);
-                return message.Response;
-            }
+            var message = new HttpPipelineMessage(cancellationToken);
+            message.Request = request;
+            message.ResponseClassifier = _responseClassifier;
+            await _pipeline.Span[0].ProcessAsync(message, _pipeline.Slice(1)).ConfigureAwait(false);
+            return message.Response;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public Response SendRequest(Request request, CancellationToken cancellationToken)
         {
-            using (var message = new HttpPipelineMessage(cancellationToken))
-            {
-                message.Request = request;
-                message.ResponseClassifier = _responseClassifier;
-                _pipeline.Span[0].Process(message, _pipeline.Slice(1));
-                return message.Response;
-            }
+            var message = new HttpPipelineMessage(cancellationToken);
+            message.Request = request;
+            message.ResponseClassifier = _responseClassifier;
+            _pipeline.Span[0].Process(message, _pipeline.Slice(1));
+            return message.Response;
         }
 
         public static HttpPipeline Build(HttpClientOptions options, ResponseClassifier responseClassifier, params HttpPipelinePolicy[] clientPolicies)
@@ -77,7 +71,7 @@ public static HttpPipeline Build(HttpClientOptions options, ResponseClassifier r
 
             policies.RemoveAll(policy => policy == null);
 
-            return new HttpPipeline(options.Transport, policies.ToArray(), options.ResponseClassifier, options.ServiceProvider);
+            return new HttpPipeline(options.Transport, policies.ToArray(), options.ResponseClassifier);
         }
     }
 }

sdk/core/Azure.Core/src/Pipeline/HttpPipelineMessage.cs

@@ -1,42 +1,23 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
-using Azure.Core.Collections;
-using System;
-using System.ComponentModel;
 using System.Threading;
 
 namespace Azure.Core.Pipeline
 {
-    public partial class HttpPipelineMessage  : IDisposable
+    public class HttpPipelineMessage
     {
-        internal OptionsStore _options = new OptionsStore();
+        public CancellationToken CancellationToken { get; }
 
-        public CancellationToken Cancellation { get; }
-
-        public HttpMessageOptions Options => new HttpMessageOptions(this);
-
-        public HttpPipelineMessage(CancellationToken cancellation)
+        public HttpPipelineMessage(CancellationToken cancellationToken)
         {
-            Cancellation = cancellation;
+            CancellationToken = cancellationToken;
         }
 
         public Request Request { get; set; }
 
         public Response Response { get; set; }
 
         public ResponseClassifier ResponseClassifier { get; set; }
-
-        // make many of these protected internal
-        public virtual void Dispose()
-        {
-            _options.Clear();
-        }
-
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override bool Equals(object obj) => base.Equals(obj);
-
-        [EditorBrowsable(EditorBrowsableState.Never)]
-        public override int GetHashCode() => base.GetHashCode();
     }
 }

sdk/core/Azure.Core/src/Pipeline/HttpPipelineOptions.cs

@@ -29,24 +29,10 @@ public HttpPipelineTransport Transport {
 
         public ResponseClassifier ResponseClassifier { get; set; } = new ResponseClassifier();
 
-        public IServiceProvider ServiceProvider { get; set; } = EmptyServiceProvider.Singleton;
-
         public IList<HttpPipelinePolicy> PerCallPolicies { get; } = new List<HttpPipelinePolicy>();
 
         public IList<HttpPipelinePolicy> PerRetryPolicies { get; } = new List<HttpPipelinePolicy>();
 
-        public void AddService(object service, Type type = null)
-        {
-            if (service == null) throw new ArgumentNullException(nameof(service));
-
-            if (!(ServiceProvider is DictionaryServiceProvider dictionaryServiceProvider))
-            {
-                ServiceProvider = dictionaryServiceProvider = new DictionaryServiceProvider();
-            }
-
-            dictionaryServiceProvider.Add(service, type != null ? type : service.GetType());
-        }
-
         #region nobody wants to see these
         [EditorBrowsable(EditorBrowsableState.Never)]
         public override bool Equals(object obj) => base.Equals(obj);
@@ -57,28 +43,6 @@ public void AddService(object service, Type type = null)
         [EditorBrowsable(EditorBrowsableState.Never)]
         public override string ToString() => base.ToString();
         #endregion
-
-        private sealed class DictionaryServiceProvider : IServiceProvider
-        {
-            Dictionary<Type, object> _services = new Dictionary<Type, object>();
-
-            public object GetService(Type serviceType)
-            {
-                _services.TryGetValue(serviceType, out var service);
-                return service;
-            }
-
-            internal void Add(object service, Type type)
-                => _services.Add(type, service);
-        }
-
-        internal sealed class EmptyServiceProvider : IServiceProvider
-        {
-            public static IServiceProvider Singleton { get; } = new EmptyServiceProvider();
-            private EmptyServiceProvider() { }
-
-            public object GetService(Type serviceType) => null;
-        }
     }
 }
 

sdk/core/Azure.Core/src/Pipeline/HttpPipelineTransport.cs

@@ -12,6 +12,6 @@ public abstract class HttpPipelineTransport
 
         public abstract Task ProcessAsync(HttpPipelineMessage message);
 
-        public abstract Request CreateRequest(IServiceProvider services);
+        public abstract Request CreateRequest();
     }
 }

sdk/core/Azure.Core/src/Pipeline/Policies/BearerTokenAuthenticationPolicy.cs

@@ -51,8 +51,8 @@ public override void Process(HttpPipelineMessage message, ReadOnlyMemory<HttpPip
         public async Task ProcessAsync(HttpPipelineMessage message, ReadOnlyMemory<HttpPipelinePolicy> pipeline, bool async)
         {
             string token = async ?
-                    await _credential.GetTokenAsync(_scopes, message.Cancellation).ConfigureAwait(false) :
-                    _credential.GetToken(_scopes, message.Cancellation);
+                    await _credential.GetTokenAsync(_scopes, message.CancellationToken).ConfigureAwait(false) :
+                    _credential.GetToken(_scopes, message.CancellationToken);
 
             if (token != _currentToken)
             {