google_apis/gaia/gaia_oauth_client.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "google_apis/gaia/gaia_oauth_client.h"
   6
   7 #include "base/json/json_reader.h"
   8 #include "base/logging.h"
   9 #include "base/memory/scoped_ptr.h"
  10 #include "base/strings/string_util.h"
  11 #include "base/values.h"
  12 #include "google_apis/gaia/gaia_urls.h"
  13 #include "net/base/escape.h"
  14 #include "net/base/load_flags.h"
  15 #include "net/http/http_status_code.h"
  16 #include "net/url_request/url_fetcher.h"
  17 #include "net/url_request/url_fetcher_delegate.h"
  18 #include "net/url_request/url_request_context_getter.h"
  19 #include "url/gurl.h"
  20
  21 namespace {
  22 const char kAccessTokenValue[] = "access_token";
  23 const char kRefreshTokenValue[] = "refresh_token";
  24 const char kExpiresInValue[] = "expires_in";
  25 }
  26
  27 namespace gaia {
  28
  29 // Use a non-zero number, so unit tests can differentiate the URLFetcher used by
  30 // this class from other fetchers (most other code just hardcodes the ID to 0).
  31 const int GaiaOAuthClient::kUrlFetcherId = 17109006;
  32
  33 class GaiaOAuthClient::Core
  34     : public base::RefCountedThreadSafe<GaiaOAuthClient::Core>,
  35       public net::URLFetcherDelegate {
  36  public:
  37   Core(net::URLRequestContextGetter* request_context_getter)
  38       : num_retries_(0),
  39         request_context_getter_(request_context_getter),
  40         delegate_(NULL),
  41         request_type_(NO_PENDING_REQUEST) {
  42   }
  43
  44   void GetTokensFromAuthCode(const OAuthClientInfo& oauth_client_info,
  45                              const std::string& auth_code,
  46                              int max_retries,
  47                              GaiaOAuthClient::Delegate* delegate);
  48   void RefreshToken(const OAuthClientInfo& oauth_client_info,
  49                     const std::string& refresh_token,
  50                     const std::vector<std::string>& scopes,
  51                     int max_retries,
  52                     GaiaOAuthClient::Delegate* delegate);
  53   void GetUserEmail(const std::string& oauth_access_token,
  54                     int max_retries,
  55                     Delegate* delegate);
  56   void GetUserId(const std::string& oauth_access_token,
  57                  int max_retries,
  58                  Delegate* delegate);
  59   void GetTokenInfo(const std::string& oauth_access_token,
  60                     int max_retries,
  61                     Delegate* delegate);
  62
  63   // net::URLFetcherDelegate implementation.
  64   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
  65
  66  private:
  67   friend class base::RefCountedThreadSafe<Core>;
  68
  69   enum RequestType {
  70     NO_PENDING_REQUEST,
  71     TOKENS_FROM_AUTH_CODE,
  72     REFRESH_TOKEN,
  73     TOKEN_INFO,
  74     USER_EMAIL,
  75     USER_ID,
  76   };
  77
  78   virtual ~Core() {}
  79
  80   void GetUserInfo(const std::string& oauth_access_token,
  81                    int max_retries,
  82                    Delegate* delegate);
  83   void MakeGaiaRequest(const GURL& url,
  84                        const std::string& post_body,
  85                        int max_retries,
  86                        GaiaOAuthClient::Delegate* delegate);
  87   void HandleResponse(const net::URLFetcher* source,
  88                       bool* should_retry_request);
  89
  90   int num_retries_;
  91   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
  92   GaiaOAuthClient::Delegate* delegate_;
  93   scoped_ptr<net::URLFetcher> request_;
  94   RequestType request_type_;
  95 };
  96
  97 void GaiaOAuthClient::Core::GetTokensFromAuthCode(
  98     const OAuthClientInfo& oauth_client_info,
  99     const std::string& auth_code,
 100     int max_retries,
 101     GaiaOAuthClient::Delegate* delegate) {
 102   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 103   request_type_ = TOKENS_FROM_AUTH_CODE;
 104   std::string post_body =
 105       "code=" + net::EscapeUrlEncodedData(auth_code, true) +
 106       "&client_id=" + net::EscapeUrlEncodedData(oauth_client_info.client_id,
 107                                                 true) +
 108       "&client_secret=" +
 109       net::EscapeUrlEncodedData(oauth_client_info.client_secret, true) +
 110       "&redirect_uri=" +
 111       net::EscapeUrlEncodedData(oauth_client_info.redirect_uri, true) +
 112       "&grant_type=authorization_code";
 113   MakeGaiaRequest(GURL(GaiaUrls::GetInstance()->oauth2_token_url()),
 114                   post_body, max_retries, delegate);
 115 }
 116
 117 void GaiaOAuthClient::Core::RefreshToken(
 118     const OAuthClientInfo& oauth_client_info,
 119     const std::string& refresh_token,
 120     const std::vector<std::string>& scopes,
 121     int max_retries,
 122     GaiaOAuthClient::Delegate* delegate) {
 123   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 124   request_type_ = REFRESH_TOKEN;
 125   std::string post_body =
 126       "refresh_token=" + net::EscapeUrlEncodedData(refresh_token, true) +
 127       "&client_id=" + net::EscapeUrlEncodedData(oauth_client_info.client_id,
 128                                                 true) +
 129       "&client_secret=" +
 130       net::EscapeUrlEncodedData(oauth_client_info.client_secret, true) +
 131       "&grant_type=refresh_token";
 132
 133   if (!scopes.empty()) {
 134     std::string scopes_string = JoinString(scopes, ' ');
 135     post_body += "&scope=" + net::EscapeUrlEncodedData(scopes_string, true);
 136   }
 137
 138   MakeGaiaRequest(GURL(GaiaUrls::GetInstance()->oauth2_token_url()),
 139                   post_body, max_retries, delegate);
 140 }
 141
 142 void GaiaOAuthClient::Core::GetUserEmail(const std::string& oauth_access_token,
 143                                          int max_retries,
 144                                          Delegate* delegate) {
 145   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 146   DCHECK(!request_.get());
 147   request_type_ = USER_EMAIL;
 148   GetUserInfo(oauth_access_token, max_retries, delegate);
 149 }
 150
 151 void GaiaOAuthClient::Core::GetUserId(const std::string& oauth_access_token,
 152                                       int max_retries,
 153                                       Delegate* delegate) {
 154   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 155   DCHECK(!request_.get());
 156   request_type_ = USER_ID;
 157   GetUserInfo(oauth_access_token, max_retries, delegate);
 158 }
 159
 160 void GaiaOAuthClient::Core::GetUserInfo(const std::string& oauth_access_token,
 161                                         int max_retries,
 162                                         Delegate* delegate) {
 163   delegate_ = delegate;
 164   num_retries_ = 0;
 165   request_.reset(net::URLFetcher::Create(
 166       kUrlFetcherId, GURL(GaiaUrls::GetInstance()->oauth_user_info_url()),
 167       net::URLFetcher::GET, this));
 168   request_->SetRequestContext(request_context_getter_.get());
 169   request_->AddExtraRequestHeader("Authorization: OAuth " + oauth_access_token);
 170   request_->SetMaxRetriesOn5xx(max_retries);
 171   request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
 172                          net::LOAD_DO_NOT_SAVE_COOKIES);
 173
 174   // Fetchers are sometimes cancelled because a network change was detected,
 175   // especially at startup and after sign-in on ChromeOS. Retrying once should
 176   // be enough in those cases; let the fetcher retry up to 3 times just in case.
 177   // http://crbug.com/163710
 178   request_->SetAutomaticallyRetryOnNetworkChanges(3);
 179   request_->Start();
 180 }
 181
 182 void GaiaOAuthClient::Core::GetTokenInfo(const std::string& oauth_access_token,
 183                                          int max_retries,
 184                                          Delegate* delegate) {
 185   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 186   DCHECK(!request_.get());
 187   request_type_ = TOKEN_INFO;
 188   std::string post_body =
 189       "access_token=" + net::EscapeUrlEncodedData(oauth_access_token, true);
 190   MakeGaiaRequest(GURL(GaiaUrls::GetInstance()->oauth2_token_info_url()),
 191                   post_body,
 192                   max_retries,
 193                   delegate);
 194 }
 195
 196 void GaiaOAuthClient::Core::MakeGaiaRequest(
 197     const GURL& url,
 198     const std::string& post_body,
 199     int max_retries,
 200     GaiaOAuthClient::Delegate* delegate) {
 201   DCHECK(!request_.get()) << "Tried to fetch two things at once!";
 202   delegate_ = delegate;
 203   num_retries_ = 0;
 204   request_.reset(net::URLFetcher::Create(
 205       kUrlFetcherId, url, net::URLFetcher::POST, this));
 206   request_->SetRequestContext(request_context_getter_.get());
 207   request_->SetUploadData("application/x-www-form-urlencoded", post_body);
 208   request_->SetMaxRetriesOn5xx(max_retries);
 209   request_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
 210                          net::LOAD_DO_NOT_SAVE_COOKIES);
 211   // See comment on SetAutomaticallyRetryOnNetworkChanges() above.
 212   request_->SetAutomaticallyRetryOnNetworkChanges(3);
 213   request_->Start();
 214 }
 215
 216 // URLFetcher::Delegate implementation.
 217 void GaiaOAuthClient::Core::OnURLFetchComplete(
 218     const net::URLFetcher* source) {
 219   bool should_retry = false;
 220   HandleResponse(source, &should_retry);
 221   if (should_retry) {
 222     // Explicitly call ReceivedContentWasMalformed() to ensure the current
 223     // request gets counted as a failure for calculation of the back-off
 224     // period.  If it was already a failure by status code, this call will
 225     // be ignored.
 226     request_->ReceivedContentWasMalformed();
 227     num_retries_++;
 228     // We must set our request_context_getter_ again because
 229     // URLFetcher::Core::RetryOrCompleteUrlFetch resets it to NULL...
 230     request_->SetRequestContext(request_context_getter_.get());
 231     request_->Start();
 232   }
 233 }
 234
 235 void GaiaOAuthClient::Core::HandleResponse(
 236     const net::URLFetcher* source,
 237     bool* should_retry_request) {
 238   // Move ownership of the request fetcher into a local scoped_ptr which
 239   // will be nuked when we're done handling the request, unless we need
 240   // to retry, in which case ownership will be returned to request_.
 241   scoped_ptr<net::URLFetcher> old_request = request_.Pass();
 242   DCHECK_EQ(source, old_request.get());
 243
 244   // HTTP_BAD_REQUEST means the arguments are invalid.  HTTP_UNAUTHORIZED means
 245   // the access or refresh token is invalid. No point retrying. We are
 246   // done here.
 247   int response_code = source->GetResponseCode();
 248   if (response_code == net::HTTP_BAD_REQUEST ||
 249       response_code == net::HTTP_UNAUTHORIZED) {
 250     delegate_->OnOAuthError();
 251     return;
 252   }
 253
 254   scoped_ptr<base::DictionaryValue> response_dict;
 255   if (source->GetResponseCode() == net::HTTP_OK) {
 256     std::string data;
 257     source->GetResponseAsString(&data);
 258     scoped_ptr<base::Value> message_value(base::JSONReader::Read(data));
 259     if (message_value.get() &&
 260         message_value->IsType(base::Value::TYPE_DICTIONARY)) {
 261       response_dict.reset(
 262           static_cast<base::DictionaryValue*>(message_value.release()));
 263     }
 264   }
 265
 266   if (!response_dict.get()) {
 267     // If we don't have an access token yet and the the error was not
 268     // RC_BAD_REQUEST, we may need to retry.
 269     if ((source->GetMaxRetriesOn5xx() != -1) &&
 270         (num_retries_ >= source->GetMaxRetriesOn5xx())) {
 271       // Retry limit reached. Give up.
 272       delegate_->OnNetworkError(source->GetResponseCode());
 273     } else {
 274       request_ = old_request.Pass();
 275       *should_retry_request = true;
 276     }
 277     return;
 278   }
 279
 280   RequestType type = request_type_;
 281   request_type_ = NO_PENDING_REQUEST;
 282
 283   switch (type) {
 284     case USER_EMAIL: {
 285       std::string email;
 286       response_dict->GetString("email", &email);
 287       delegate_->OnGetUserEmailResponse(email);
 288       break;
 289     }
 290
 291     case USER_ID: {
 292       std::string id;
 293       response_dict->GetString("id", &id);
 294       delegate_->OnGetUserIdResponse(id);
 295       break;
 296     }
 297
 298     case TOKEN_INFO: {
 299       delegate_->OnGetTokenInfoResponse(response_dict.Pass());
 300       break;
 301     }
 302
 303     case TOKENS_FROM_AUTH_CODE:
 304     case REFRESH_TOKEN: {
 305       std::string access_token;
 306       std::string refresh_token;
 307       int expires_in_seconds = 0;
 308       response_dict->GetString(kAccessTokenValue, &access_token);
 309       response_dict->GetString(kRefreshTokenValue, &refresh_token);
 310       response_dict->GetInteger(kExpiresInValue, &expires_in_seconds);
 311
 312       if (access_token.empty()) {
 313         delegate_->OnOAuthError();
 314         return;
 315       }
 316
 317       if (type == REFRESH_TOKEN) {
 318         delegate_->OnRefreshTokenResponse(access_token, expires_in_seconds);
 319       } else {
 320         delegate_->OnGetTokensResponse(refresh_token,
 321                                        access_token,
 322                                        expires_in_seconds);
 323       }
 324       break;
 325     }
 326
 327     default:
 328       NOTREACHED();
 329   }
 330 }
 331
 332 GaiaOAuthClient::GaiaOAuthClient(net::URLRequestContextGetter* context_getter) {
 333   core_ = new Core(context_getter);
 334 }
 335
 336 GaiaOAuthClient::~GaiaOAuthClient() {
 337 }
 338
 339 void GaiaOAuthClient::GetTokensFromAuthCode(
 340     const OAuthClientInfo& oauth_client_info,
 341     const std::string& auth_code,
 342     int max_retries,
 343     Delegate* delegate) {
 344   return core_->GetTokensFromAuthCode(oauth_client_info,
 345                                       auth_code,
 346                                       max_retries,
 347                                       delegate);
 348 }
 349
 350 void GaiaOAuthClient::RefreshToken(
 351     const OAuthClientInfo& oauth_client_info,
 352     const std::string& refresh_token,
 353     const std::vector<std::string>& scopes,
 354     int max_retries,
 355     Delegate* delegate) {
 356   return core_->RefreshToken(oauth_client_info,
 357                              refresh_token,
 358                              scopes,
 359                              max_retries,
 360                              delegate);
 361 }
 362
 363 void GaiaOAuthClient::GetUserEmail(const std::string& access_token,
 364                                   int max_retries,
 365                                   Delegate* delegate) {
 366   return core_->GetUserEmail(access_token, max_retries, delegate);
 367 }
 368
 369 void GaiaOAuthClient::GetUserId(const std::string& access_token,
 370                                 int max_retries,
 371                                 Delegate* delegate) {
 372   return core_->GetUserId(access_token, max_retries, delegate);
 373 }
 374
 375 void GaiaOAuthClient::GetTokenInfo(const std::string& access_token,
 376                                    int max_retries,
 377                                    Delegate* delegate) {
 378   return core_->GetTokenInfo(access_token, max_retries, delegate);
 379 }
 380
 381 }  // namespace gaia