Reimplement OAuth2 library - Step 1

Src/GoogleApis/Apis/Http/BackOffHandler.cs

Index: Src/GoogleApis/Apis/Http/BackOffHandler.cs
===================================================================
--- a/Src/GoogleApis/Apis/Http/BackOffHandler.cs
 b/Src/GoogleApis/Apis/Http/BackOffHandler.cs
@@ -18,49 18,50 @@
 using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Google.Apis.Logging;
 using Google.Apis.Util;
 namespace Google.Apis.Http
 {
 /// <summary>
- /// A thread-safe back-off handler which handles an abnormal Http response or an exception with
 /// A thread-safe back-off handler which handles an abnormal HTTP response or an exception with
 /// <see cref="IBackOff"/>.
 /// </summary>
 public class BackOffHandler : IHttpUnsuccessfulResponseHandler, IHttpExceptionHandler
 {
 private static readonly ILogger Logger = ApplicationContext.Logger.ForType<BackOffHandler>();
- /// <summary> An initializer class to initialize a back-off handler. </summary>
 /// <summary>An initializer class to initialize a back-off handler.</summary>
 public class Initializer
 {
- /// <summary> Gets the back-off policy used by this back-off handler. </summary>
 /// <summary>Gets the back-off policy used by this back-off handler.</summary>
 public IBackOff BackOff { get; private set; }
- /// <summary>
 /// <summary>
 /// Gets or sets the maximum time span to wait. If the back-off instance returns a greater time span then
- /// this value, this handler returns <c>false</c> to both <see cref="HandleException"/> and
- /// <see cref="HandleResponse"/>. Default value is 5 seconds per a retry request.
 /// this value, this handler returns <c>false</c> to both <see cref="HandleExceptionAsync"/> and
 /// <see cref="HandleResponseAsync"/>. Default value is 5 seconds per a retry request.
 /// </summary>
 public TimeSpan MaxTimeSpan { get; set; }
- /// <summary>
 /// <summary>
 /// Gets or sets a delegate function which indicates if this back-off handler should handle an abnormal
- /// Http response. The default is <see cref="DefaultHandleUnsuccessfulResponse"/>.
 /// HTTP response. The default is <see cref="DefaultHandleUnsuccessfulResponseFunc"/>.
 /// </summary>
 public Func<HttpResponseMessage, bool> HandleUnsuccessfulResponseFunc { get; set; }
- /// <summary>
 /// <summary>
 /// Gets or sets a delegate function which indicates if this back-off handler should handle an exception.
- /// The default is <see cref="DefaultHandleException"/>.
 /// The default is <see cref="DefaultHandleExceptionFunc"/>.
 /// </summary>
 public Func<Exception, bool> HandleExceptionFunc { get; set; }
- /// <summary> Default function which handles server errors (503). </summary>
 /// <summary>Default function which handles server errors (503).</summary>
 public static readonly Func<HttpResponseMessage, bool> DefaultHandleUnsuccessfulResponseFunc =
 (r) => (int)r.StatusCode == 503;
- /// <summary>
 /// <summary>
 /// Default function which handles exception which aren't
 /// <seealso cref="System.Threading.Tasks.TaskCanceledException"/> or
 /// <seealso cref="System.OperationCanceledException"/>. Those exceptions represent a task or an operation
@@ -69,7 70,7 @@
 public static readonly Func<Exception, bool> DefaultHandleExceptionFunc =
 (ex) => !(ex is TaskCanceledException || ex is OperationCanceledException);
- /// <summary> Constructs a new initializer by the given back-off. </summary>
 /// <summary>Constructs a new initializer by the given back-off.</summary>
 public Initializer(IBackOff backOff)
 {
 BackOff = backOff;
@@ -79,34 80,35 @@
 }
 }
- /// <summary> Gets the back-off policy used by this back-off handler. </summary>
 /// <summary>Gets the back-off policy used by this back-off handler.</summary>
 public IBackOff BackOff { get; private set; }
- /// <summary>
 /// <summary>
 /// Gets the maximum time span to wait. If the back-off instance returns a greater time span, the handle method
 /// returns <c>false</c>. Default value is 5 seconds per a retry request.
 /// </summary>
 public TimeSpan MaxTimeSpan { get; private set; }
- /// <summary>
- /// Gets a delegate function which indicates if this back-off handler should handle an abnormal Http response.
- /// The default is <see cref="DefaultHandleUnsuccessfulResponse"/>.
 /// <summary>
 /// Gets a delegate function which indicates if this back-off handler should handle an abnormal HTTP response.
 /// The default is <see cref="DefaultHandleUnsuccessfulResponseFunc"/>.
 /// </summary>
 public Func<HttpResponseMessage, bool> HandleUnsuccessfulResponseFunc { get; private set; }
- /// <summary>
 /// <summary>
 /// Gets a delegate function which indicates if this back-off handler should handle an exception. The
- /// default is <see cref="DefaultHandleException"/>.
 /// default is <see cref="DefaultHandleExceptionFunc"/>.
 /// </summary>
 public Func<Exception, bool> HandleExceptionFunc { get; private set; }
- /// <summary> Constructs a new back-off handler with the given back-off. </summary>
 /// <summary>Constructs a new back-off handler with the given back-off.</summary>
 /// <param name="backOff">The back-off policy</param>
 public BackOffHandler(IBackOff backOff)
 : this(new Initializer(backOff))
 {
 }
- /// <summary> Constructs a new back-off handler with the given initializer. </summary>
 /// <summary>Constructs a new back-off handler with the given initializer.</summary>
 public BackOffHandler(Initializer initializer)
 {
 BackOff = initializer.BackOff;
@@ -117,22 119,22 @@
 #region IHttpUnsuccessfulResponseHandler
- public virtual bool HandleResponse(HandleUnsuccessfulResponseArgs args)
 public virtual async Task<bool> HandleResponseAsync(HandleUnsuccessfulResponseArgs args)
 {
 // if the func returns true try to handle this current failed try
 return HandleUnsuccessfulResponseFunc != null && HandleUnsuccessfulResponseFunc(args.Response) &&
- Handle(args.SupportsRetry, args.CurrentFailedTry, args.CancellationToken);
 await HandleAsync(args.SupportsRetry, args.CurrentFailedTry, args.CancellationToken);
 }
 #endregion
 #region IHttpExceptionHandler
- public virtual bool HandleException(HandleExceptionArgs args)
 public virtual async Task<bool> HandleExceptionAsync(HandleExceptionArgs args)
 {
 // if the func returns true try to handle this current failed try
 return HandleExceptionFunc != null && HandleExceptionFunc(args.Exception) &&
- Handle(args.SupportsRetry, args.CurrentFailedTry, args.CancellationToken);
 await HandleAsync(args.SupportsRetry, args.CurrentFailedTry, args.CancellationToken);
 }
 #endregion
@@ -143,7 145,8 @@
 /// block for x milliseconds (x is defined by the <see cref="BackOff"/> instance), and this handler returns
 /// <c>true</c>.
 /// </summary>
- private bool Handle(bool supportsRetry, int currentFailedTry, CancellationToken cancellationToken)
 private async Task<bool> HandleAsync(bool supportsRetry, int currentFailedTry,
 CancellationToken cancellationToken)
 {
 if (!supportsRetry || BackOff.MaxNumOfRetries < currentFailedTry)
 {
@@ -156,22 159,18 @@
 return false;
 }
- Wait(ts, cancellationToken);
 await Wait(ts, cancellationToken);
 Logger.Debug("Back-Off handled the error. Waited {0}ms before next retry...", ts.TotalMilliseconds);
 return true;
 }
- /// <summary> Waits the given time span. Override this method is recommended for mocking purposes.</summary>
 /// <summary>Waits the given time span. Override this method is recommended for mocking purposes.</summary>
 /// <param name="ts">TimeSpan to wait (and block the current thread)</param>
 /// <param name="cancellationToken">The cancellation token in case the user wants to cancel the operation in
 /// the middle</param>
- protected virtual void Wait(TimeSpan ts, CancellationToken cancellationToken)
 protected virtual async Task Wait(TimeSpan ts, CancellationToken cancellationToken)
 {
- try
- {
- TaskEx.Delay(ts, cancellationToken).Wait();
- }
- catch (Exception) { }
 await TaskEx.Delay(ts, cancellationToken);
 }
 }
 }