Reimplement OAuth2 library - Step 1

Src/GoogleApis/Apis/Services/BaseClientService.cs

 /*
 Copyright 2013 Google Inc
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
 http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
@@ skipping 24 matching lines @@
 
 namespace Google.Apis.Services
 {
 /// <summary>
 /// A thread-safe base class for a client service which provides common mech
anism for all services, like·
 /// serialization and GZip support.
 /// This class adds a special <see cref="Google.Apis.Http.IHttpExecuteInterc
eptor"/> to the·
 /// <see cref="Google.Apis.Http.ConfigurableMessageHandler"/> execute interc
eptor list, which uses the given·
 /// Authenticator. It calls to its applying authentication method, and injec
ts the "Authorization" header in the·
 /// request.
- /// If the given Authenticator implements <see cref="Google.Apis.Http.IUnsuc
 cessfulReponseHandler"/>, this class
- /// adds the Authenticator to the <see cref="Google.Apis.Http.ConfigurableMe
 ssageHandler"/>'s unsuccessful response
- /// handler list.
+ /// If the given Authenticator implements <see cref="Google.Apis.Http.IHttpU
 nsuccessfulResponseHandler"/>, this·
+ /// class adds the Authenticator to the <see cref="Google.Apis.Http.Configur
 ableMessageHandler"/>'s unsuccessful·
+ /// response handler list.
 /// </summary>
 public abstract class BaseClientService : IClientService
 {
- /// <summary> The class logger. </summary>
+ /// <summary>The class logger.</summary>
 private static readonly ILogger Logger = ApplicationContext.Logger.ForTy
pe<BaseClientService>();
 
 #region Initializer
 
- /// <summary>·
- /// Indicates if exponential back-off is used automatically on exception
  in a service request and\or when 503·
- /// response is returned form the server.
- /// </summary>
- [Flags]
- public enum ExponentialBackOffPolicy
- {
- None = 0,
- Exception = 1,
- UnsuccessfulResponse503 = 2
- }
-
- /// <summary> An initializer class for the client service. </summary>
+ /// <summary>An initializer class for the client service.</summary>
 public class Initializer
 {
- /// <summary> 
+ /// <summary>
 /// Gets or sets the factory for creating <see cref="System.Net.Http
.HttpClient"/> instance. If this·
 /// property is not set the service uses a new <see cref="Google.Api
s.Http.HttpClientFactory"/> instance.
 /// </summary>
 public IHttpClientFactory HttpClientFactory { get; set; }
 
 /// <summary>
- /// Gets or sets an Http client initializer which is able to customi
 ze properties on·
+ /// Gets or sets a HTTP client initializer which is able to customiz
 e properties on·
 /// <see cref="Google.Apis.Http.ConfigurableHttpClient"/> and·
 /// <see cref="Google.Apis.Http.ConfigurableMessageHandler"/>.
 /// </summary>
 public IConfigurableHttpClientInitializer HttpClientInitializer { ge
t; set; }
 
 /// <summary>
 /// Get or sets the exponential back-off policy used by the service.
Default value is·
 /// <c>UnsuccessfulResponse503</c>, which means that exponential bac
k-off is used on 503 abnormal HTTP
 /// response.
 /// If the value is set to <c>None</c>, no exponential back-off poli
cy is used, and it's up to user to
 /// configure the <seealso cref="Google.Apis.Http.ConfigurableMessag
eHandler"/> in an
 /// <seealso cref="Google.Apis.Http.IConfigurableHttpClientInitializ
er"/> to set a specific back-off
- /// implementation (using <seealso cref="Google.Api.Http.BackOffHand
 ler"/>).
+ /// implementation (using <seealso cref="Google.Apis.Http.BackOffHan
 dler"/>).
 /// </summary>
 public ExponentialBackOffPolicy DefaultExponentialBackOffPolicy { ge
t; set; }
 
- /// <summary> Gets or sets whether this service supports GZip. Defau
 lt value is <c>true</c>. </summary>
+ /// <summary>Gets or sets whether this service supports GZip. Defaul
 t value is <c>true</c>.</summary>
 public bool GZipEnabled { get; set; }
 
 /// <summary>
- /// Gets and Sets the Serializer. Default value is <see cref="Google
 .Apis.Json.NewtonsoftJsonSerializer"/>.
+ /// Gets and Sets the serializer. Default value is <see cref="Google
 .Apis.Json.NewtonsoftJsonSerializer"/>.
 /// </summary>
 public ISerializer Serializer { get; set; }
 
- /// <summary> Gets or sets the API Key. Default value is <c>null</c>
 . </summary>
+ /// <summary>Gets or sets the API Key. Default value is <c>null</c>.
 </summary>
 public string ApiKey { get; set; }
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets the Authenticator. Default value is·
 /// <see cref="Google.Apis.Authentication.NullAuthenticator.Instance
"/>.
 /// </summary>
 public IAuthenticator Authenticator { get; set; }
 
- /// <summary> 
+ /// <summary>
 /// Gets or sets Application name to be used in the User-Agent heade
r. Default value is <c>null</c>.·
 /// </summary>
 public string ApplicationName { get; set; }
 
- /// <summary> Constructs a new initializer with default values. </su
 mmary>
+ /// <summary>Constructs a new initializer with default values.</summ
 ary>
 public Initializer()
 {
 GZipEnabled = true;
 Serializer = new NewtonsoftJsonSerializer();
 Authenticator = NullAuthenticator.Instance;
 DefaultExponentialBackOffPolicy = ExponentialBackOffPolicy.Unsuc
cessfulResponse503;
 }
 }
 
-/// <summary>
-/// An initializer which adds exponential back-off as exception handler
and\or unsuccessful response handler by
-/// the given <seealso cref="BaseClientService.ExponentialBackOffPolicy"
/>.
-/// </summary>
-private class ExponentialBackOffInitializer : IConfigurableHttpClientIni
tializer
-{
-private ExponentialBackOffPolicy Policy { get; set; }
-private Func<BackOffHandler> CreateBackOff { get; set; }
-
-/// <summary>
-/// Constructs a new back-off initializer with the given policy and
back-off handler create function.
-/// </summary>
-public ExponentialBackOffInitializer(ExponentialBackOffPolicy policy
, Func<BackOffHandler> createBackOff)
-{
-Policy = policy;
-CreateBackOff = createBackOff;
-}
-
-public void Initialize(ConfigurableHttpClient httpClient)
-{
-var backOff = CreateBackOff();
-
-// add exception handler and\or unsuccessful response handler
-if ((Policy & ExponentialBackOffPolicy.Exception) == Exponential
BackOffPolicy.Exception)
-{
-httpClient.MessageHandler.ExceptionHandlers.Add(backOff);
-}
-
-if ((Policy & ExponentialBackOffPolicy.UnsuccessfulResponse503)
==
-ExponentialBackOffPolicy.UnsuccessfulResponse503)
-{
-httpClient.MessageHandler.UnsuccessfulResponseHandlers.Add(b
ackOff);
-}
-}
-}
-
 #endregion
 
- /// <summary> Constructs a new base client with the specified initialize
 r. </summary>
+ /// <summary>Constructs a new base client with the specified initializer
 .</summary>
 protected BaseClientService(Initializer initializer)
 {
- // sets the right properties by the initializer's properties
+ // Set the right properties by the initializer's properties.
 GZipEnabled = initializer.GZipEnabled;
 Serializer = initializer.Serializer;
 ApiKey = initializer.ApiKey;
 Authenticator = initializer.Authenticator;
 ApplicationName = initializer.ApplicationName;
 if (ApplicationName == null)
 {
 Logger.Warning("Application name is not set. Please set Initiali
zer.ApplicationName property");
 }
 HttpClientInitializer = initializer.HttpClientInitializer;
 
- // create an Http client for this service
+ // Create a HTTP client for this service.
 HttpClient = CreateHttpClient(initializer);
 }
 
- /// <summary> Return <c>true</c> if this service contains the specified 
 feature. </summary>
+ /// <summary>Returns <c>true</c> if this service contains the specified 
 feature.</summary>
 private bool HasFeature(Features feature)
 {
 return Features.Contains(feature.GetStringValue());
 }
 
 private ConfigurableHttpClient CreateHttpClient(Initializer initializer)
 {
- // if factory wasn't set use the default Http client factory
+ // If factory wasn't set use the default HTTP client factory.
 var factory = initializer.HttpClientFactory ?? new HttpClientFactory
();
 var args = new CreateHttpClientArgs
 {
 GZipEnabled = GZipEnabled,
 ApplicationName = ApplicationName,
 };
 
- // add the user's input initializer
+ // Add the user's input initializer.
 if (HttpClientInitializer != null)
 {
 args.Initializers.Add(HttpClientInitializer);
 }
 
- // add exponential back-off initializer if necessary
+ // Add exponential back-off initializer if necessary.
 if (initializer.DefaultExponentialBackOffPolicy != ExponentialBackOf
fPolicy.None)
 {
 args.Initializers.Add(new ExponentialBackOffInitializer(initiali
zer.DefaultExponentialBackOffPolicy,
 CreateBackOffHandler));
 }
 
- // add authenticator initializer to intercept a request and add the 
 "Authorization" header and also handle
+ // Add authenticator initializer to intercept a request and add the 
 "Authorization" header and also handle
 // abnormal 401 responses in case the authenticator is an instance o
f unsuccessful response handler.
 args.Initializers.Add(new AuthenticatorMessageHandlerInitializer(Aut
henticator));
 
 return factory.CreateHttpClient(args);
 }
 
 /// <summary>
 /// Creates the back-off handler with <seealso cref="Google.Apis.Util.Ex
ponentialBackOff"/>.·
 /// Overrides this method to change the default behavior of back-off han
dler (e.g. you can change the maximum
 /// waited request's time span, or create a back-off handler with you ow
n implementation of·
@@ skipping 53 matching lines @@
 public ISerializer Serializer { get; private set; }
 
 public virtual string SerializeObject(object obj)
 {
 if (HasFeature(Discovery.Features.LegacyDataResponse))
 {
 // Legacy path
 var request = new StandardResponse<object> { Data = obj };
 return Serializer.Serialize(request);
 }
-
-// New v1.0 path
 return Serializer.Serialize(obj);
 }
 
 public virtual async Task<T> DeserializeResponse<T>(HttpResponseMessage
response)
 {
 var text = await response.Content.ReadAsStringAsync().ConfigureAwait
(false);
 
 // If a string is request, don't parse the response.
 if (typeof(T).Equals(typeof(string)))
 {
@@ skipping 68 matching lines @@
 // Standard response (which contains data and error properties)
 throw new GoogleApiException(Name,
 "An Error occurred, but the error response could not be dese
rialized", ex);
 }
 
 return errorResponse.Error;
 }
 
 #endregion
 
- #region Abstract Memebrs
+ #region Abstract Members
 
 public abstract string Name { get; }
 public abstract string BaseUri { get; }
 public abstract string BasePath { get; }
 
 public abstract IList<string> Features { get; }
 
 #endregion
 
 #endregion
 
- /// <summary> Creates a GZip stream by the given serialized object. </su
 mmary>
+ /// <summary>Creates a GZip stream by the given serialized object.</summ
 ary>
 private static Stream CreateGZipStream(string serializedObject)
 {
 byte[] bytes = System.Text.Encoding.UTF8.GetBytes(serializedObject);
 using (System.IO.MemoryStream ms = new System.IO.MemoryStream())
 {
 using (GZipStream gzip = new GZipStream(ms, CompressionMode.Comp
ress, true))
 {
 gzip.Write(bytes, 0, bytes.Length);
 }
 
 // reset the stream to the beginning. It doesn't work otherwise!
 ms.Position = 0;
 byte[] compressed = new byte[ms.Length];
 ms.Read(compressed, 0, compressed.Length);
 return new MemoryStream(compressed);
 }
 }
 
 public virtual void Dispose()
 {
 if (HttpClient != null)
 {
 HttpClient.Dispose();
 }
 }
 }
 }