Issue 351: Reimplement OAuth2 (Step 3 - Tests, Flows and Credential)

Src/GoogleApis.Auth/OAuth2/Credential.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 17 matching lines @@
 {
 /// <summary>
 /// OAuth 2.0 credential for accessing protected resources using an access t
oken, as well as optionally refreshing·
 /// the access token when it expires using a refresh token.
 /// </summary>
 public class Credential : IHttpExecuteInterceptor, IHttpUnsuccessfulResponse
Handler,
 IConfigurableHttpClientInitializer
 {
 private static readonly ILogger Logger = ApplicationContext.Logger.ForTy
pe<Credential>();
 
- private readonly TokenResponse token;
+ private TokenResponse token;
+ private object lockObject = new object();
+
+ public TokenResponse Token
+ {
+ get
+ {
+ lock (lockObject)
+ {
+ return token;
+ }
+ }
+ private set
+ {
+ lock (lockObject)
+ {
+ token = value;
+ }
+ }
+ }
+
 private readonly IAuthorizationCodeFlow flow;
 private readonly string userId;
 
 /// <summary>Constructs a new credential instance.</summary>
 /// <param name="flow">Authorization code flow</param>
 /// <param name="userId">User identifier</param>
 /// <param name="token">An initial token for the user</param>
 public Credential(IAuthorizationCodeFlow flow, string userId, TokenRespo
nse token)
 {
 this.flow = flow;
+this.userId = userId;
 this.token = token;
-this.userId = userId;
 }
 
 /// <summary>
 /// Default implementation is to try to refresh the access token if ther
e is no access token or if we are 1·
 /// minute away from expiration. If token server is unavailable, it will
try to use the access token even if·
 /// has expired. If successful, it will call <seealso cref="IAccessMetho
d.Intercept"/>.
 /// </summary>
 public async Task InterceptAsync(HttpRequestMessage request, Cancellatio
nToken taskCancellationToken)
 {
- if (token.IsExpired(flow.Clock))
+ if (Token.IsExpired(flow.Clock))
 {
 if (!await RefreshTokenAsync(taskCancellationToken).ConfigureAwa
it(false))
 {
 throw new InvalidOperationException("The access token is exp
ired but we can't refresh it");
 }
 }
 
- flow.AccessMethod.Intercept(request, token.AccessToken);
+ flow.AccessMethod.Intercept(request, Token.AccessToken);
 }
 
 /// <summary>
 /// Refreshes the token by calling to <seealso cref="IAuthorizationCodeF
low.RefreshTokenAsync"/>. Then it·
 /// updates the <see cref="TokenResponse"/> with the new token instance.
 /// </summary>
 /// <param name="taskCancellationToken">Cancellation token to cancel an
operation</param>
 /// <returns><c>true</c> if the token was refreshed</returns>
 private async Task<bool> RefreshTokenAsync(CancellationToken taskCancell
ationToken)
 {
- if (token.RefreshToken == null)
+ if (Token.RefreshToken == null)
 {
 Logger.Warning("Refresh token is null, can't refresh the token!"
);
 return false;
 }
 
 // It's possible that two concurrent calls will be made to refresh t
he token, in that case the last one·
 // will win.
- var newToken = await flow.RefreshTokenAsync(userId, token.RefreshTok
 en, taskCancellationToken)
+ var newToken = await flow.RefreshTokenAsync(userId, Token.RefreshTok
 en, taskCancellationToken)
 .ConfigureAwait(false);
 
 Logger.Info("Access token was refreshed");
 
- token.CopyFrom(newToken);
+ if (newToken.RefreshToken == null)
+ {
+ newToken.RefreshToken = Token.RefreshToken;
+ }
 
+Token = newToken;
 return true;
 }
 
 public async Task<bool> HandleResponseAsync(HandleUnsuccessfulResponseAr
gs args)
 {
 // TODO(peleyal): check WWW-Authenticate header
 if (args.Response.StatusCode == HttpStatusCode.Unauthorized)
 {
- return !Object.Equals(token.AccessToken, flow.AccessMethod.GetAc
 cessToken(args.Request))
+ return !Object.Equals(Token.AccessToken, flow.AccessMethod.GetAc
 cessToken(args.Request))
 || await RefreshTokenAsync(args.CancellationToken).Configure
Await(false);
 }
 
 return false;
 }
 
 public void Initialize(ConfigurableHttpClient httpClient)
 {
 httpClient.MessageHandler.ExecuteInterceptors.Add(this);
 httpClient.MessageHandler.UnsuccessfulResponseHandlers.Add(this);
 }
 }
 }