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/values.h"
  11 #include "google_apis/gaia/gaia_urls.h"
  12 #include "googleurl/src/gurl.h"
  13 #include "net/base/escape.h"
  14 #include "net/http/http_status_code.h"
  15 #include "net/url_request/url_fetcher.h"
  16 #include "net/url_request/url_fetcher_delegate.h"
  17 #include "net/url_request/url_request_context_getter.h"
  18
  19 namespace {
  20 const char kAccessTokenValue[] = "access_token";
  21 const char kRefreshTokenValue[] = "refresh_token";
  22 const char kExpiresInValue[] = "expires_in";
  23 }
  24
  25 namespace gaia {
  26
  27 class GaiaOAuthClient::Core
  28     : public base::RefCountedThreadSafe<GaiaOAuthClient::Core>,
  29       public net::URLFetcherDelegate {
  30  public:
  31   Core(const std::string& gaia_url,
  32        net::URLRequestContextGetter* request_context_getter)
  33            : gaia_url_(gaia_url),
  34              num_retries_(0),
  35              request_context_getter_(request_context_getter),
  36              delegate_(NULL),
  37              request_type_(NO_PENDING_REQUEST) {
  38   }
  39
  40   void GetTokensFromAuthCode(const OAuthClientInfo& oauth_client_info,
  41                              const std::string& auth_code,
  42                              int max_retries,
  43                              GaiaOAuthClient::Delegate* delegate);
  44   void RefreshToken(const OAuthClientInfo& oauth_client_info,
  45                     const std::string& refresh_token,
  46                     int max_retries,
  47                     GaiaOAuthClient::Delegate* delegate);
  48   void GetUserInfo(const std::string& oauth_access_token,
  49                     int max_retries,
  50                     Delegate* delegate);
  51
  52   // net::URLFetcherDelegate implementation.
  53   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE;
  54
  55  private:
  56   friend class base::RefCountedThreadSafe<Core>;
  57
  58   enum RequestType {
  59     NO_PENDING_REQUEST,
  60     TOKENS_FROM_AUTH_CODE,
  61     REFRESH_TOKEN,
  62     USER_INFO,
  63   };
  64
  65   virtual ~Core() {}
  66
  67   void MakeGaiaRequest(const std::string& post_body,
  68                        int max_retries,
  69                        GaiaOAuthClient::Delegate* delegate);
  70   void HandleResponse(const net::URLFetcher* source,
  71                       bool* should_retry_request);
  72
  73   GURL gaia_url_;
  74   int num_retries_;
  75   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
  76   GaiaOAuthClient::Delegate* delegate_;
  77   scoped_ptr<net::URLFetcher> request_;
  78   RequestType request_type_;
  79 };
  80
  81 void GaiaOAuthClient::Core::GetTokensFromAuthCode(
  82     const OAuthClientInfo& oauth_client_info,
  83     const std::string& auth_code,
  84     int max_retries,
  85     GaiaOAuthClient::Delegate* delegate) {
  86   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
  87   request_type_ = TOKENS_FROM_AUTH_CODE;
  88   std::string post_body =
  89       "code=" + net::EscapeUrlEncodedData(auth_code, true) +
  90       "&client_id=" + net::EscapeUrlEncodedData(oauth_client_info.client_id,
  91                                                 true) +
  92       "&client_secret=" +
  93       net::EscapeUrlEncodedData(oauth_client_info.client_secret, true) +
  94       "&redirect_uri=" +
  95       net::EscapeUrlEncodedData(oauth_client_info.redirect_uri, true) +
  96       "&grant_type=authorization_code";
  97   MakeGaiaRequest(post_body, max_retries, delegate);
  98 }
  99
 100 void GaiaOAuthClient::Core::RefreshToken(
 101     const OAuthClientInfo& oauth_client_info,
 102     const std::string& refresh_token,
 103     int max_retries,
 104     GaiaOAuthClient::Delegate* delegate) {
 105   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 106   request_type_ = REFRESH_TOKEN;
 107   std::string post_body =
 108       "refresh_token=" + net::EscapeUrlEncodedData(refresh_token, true) +
 109       "&client_id=" + net::EscapeUrlEncodedData(oauth_client_info.client_id,
 110                                                 true) +
 111       "&client_secret=" +
 112       net::EscapeUrlEncodedData(oauth_client_info.client_secret, true) +
 113       "&grant_type=refresh_token";
 114   MakeGaiaRequest(post_body, max_retries, delegate);
 115 }
 116
 117 void GaiaOAuthClient::Core::GetUserInfo(const std::string& oauth_access_token,
 118                                         int max_retries,
 119                                         Delegate* delegate) {
 120   DCHECK_EQ(request_type_, NO_PENDING_REQUEST);
 121   DCHECK(!request_.get());
 122   request_type_ = USER_INFO;
 123   delegate_ = delegate;
 124   num_retries_ = 0;
 125   request_.reset(net::URLFetcher::Create(
 126       0, GURL(GaiaUrls::GetInstance()->oauth_user_info_url()),
 127       net::URLFetcher::GET, this));
 128   request_->SetRequestContext(request_context_getter_);
 129   request_->AddExtraRequestHeader(
 130       "Authorization: OAuth " + oauth_access_token);
 131   request_->SetMaxRetries(max_retries);
 132   request_->Start();
 133 }
 134
 135 void GaiaOAuthClient::Core::MakeGaiaRequest(
 136     const std::string& post_body,
 137     int max_retries,
 138     GaiaOAuthClient::Delegate* delegate) {
 139   DCHECK(!request_.get()) << "Tried to fetch two things at once!";
 140   delegate_ = delegate;
 141   num_retries_ = 0;
 142   request_.reset(net::URLFetcher::Create(
 143       0, gaia_url_, net::URLFetcher::POST, this));
 144   request_->SetRequestContext(request_context_getter_);
 145   request_->SetUploadData("application/x-www-form-urlencoded", post_body);
 146   request_->SetMaxRetries(max_retries);
 147   request_->Start();
 148 }
 149
 150 // URLFetcher::Delegate implementation.
 151 void GaiaOAuthClient::Core::OnURLFetchComplete(
 152     const net::URLFetcher* source) {
 153   bool should_retry = false;
 154   HandleResponse(source, &should_retry);
 155   if (should_retry) {
 156     // Explicitly call ReceivedContentWasMalformed() to ensure the current
 157     // request gets counted as a failure for calculation of the back-off
 158     // period.  If it was already a failure by status code, this call will
 159     // be ignored.
 160     request_->ReceivedContentWasMalformed();
 161     num_retries_++;
 162     // We must set our request_context_getter_ again because
 163     // URLFetcher::Core::RetryOrCompleteUrlFetch resets it to NULL...
 164     request_->SetRequestContext(request_context_getter_);
 165     request_->Start();
 166   }
 167 }
 168
 169 void GaiaOAuthClient::Core::HandleResponse(
 170     const net::URLFetcher* source,
 171     bool* should_retry_request) {
 172   // Keep the URLFetcher object in case we need to reuse it.
 173   scoped_ptr<net::URLFetcher> old_request = request_.Pass();
 174   DCHECK_EQ(source, old_request.get());
 175
 176   // RC_BAD_REQUEST means the arguments are invalid. No point retrying. We are
 177   // done here.
 178   if (source->GetResponseCode() == net::HTTP_BAD_REQUEST) {
 179     delegate_->OnOAuthError();
 180     return;
 181   }
 182
 183   scoped_ptr<DictionaryValue> response_dict;
 184   if (source->GetResponseCode() == net::HTTP_OK) {
 185     std::string data;
 186     source->GetResponseAsString(&data);
 187     scoped_ptr<Value> message_value(base::JSONReader::Read(data));
 188     if (message_value.get() &&
 189         message_value->IsType(Value::TYPE_DICTIONARY)) {
 190       response_dict.reset(
 191           static_cast<DictionaryValue*>(message_value.release()));
 192     }
 193   }
 194
 195   if (!response_dict.get()) {
 196     // If we don't have an access token yet and the the error was not
 197     // RC_BAD_REQUEST, we may need to retry.
 198     if ((source->GetMaxRetries() != -1) &&
 199         (num_retries_ > source->GetMaxRetries())) {
 200       // Retry limit reached. Give up.
 201       delegate_->OnNetworkError(source->GetResponseCode());
 202     } else {
 203       request_ = old_request.Pass();
 204       *should_retry_request = true;
 205     }
 206     return;
 207   }
 208
 209   RequestType type = request_type_;
 210   request_type_ = NO_PENDING_REQUEST;
 211
 212   switch (type) {
 213     case USER_INFO: {
 214       std::string email;
 215       response_dict->GetString("email", &email);
 216       delegate_->OnGetUserInfoResponse(email);
 217       break;
 218     }
 219
 220     case TOKENS_FROM_AUTH_CODE:
 221     case REFRESH_TOKEN: {
 222       std::string access_token;
 223       std::string refresh_token;
 224       int expires_in_seconds = 0;
 225       response_dict->GetString(kAccessTokenValue, &access_token);
 226       response_dict->GetString(kRefreshTokenValue, &refresh_token);
 227       response_dict->GetInteger(kExpiresInValue, &expires_in_seconds);
 228
 229       if (access_token.empty()) {
 230         delegate_->OnOAuthError();
 231         return;
 232       }
 233
 234       if (type == REFRESH_TOKEN) {
 235         delegate_->OnRefreshTokenResponse(access_token, expires_in_seconds);
 236       } else {
 237         delegate_->OnGetTokensResponse(refresh_token,
 238                                        access_token,
 239                                        expires_in_seconds);
 240       }
 241       break;
 242     }
 243
 244     default:
 245       NOTREACHED();
 246   }
 247 }
 248
 249 GaiaOAuthClient::GaiaOAuthClient(const std::string& gaia_url,
 250                                  net::URLRequestContextGetter* context_getter) {
 251   core_ = new Core(gaia_url, context_getter);
 252 }
 253
 254 GaiaOAuthClient::~GaiaOAuthClient() {
 255 }
 256
 257 void GaiaOAuthClient::GetTokensFromAuthCode(
 258     const OAuthClientInfo& oauth_client_info,
 259     const std::string& auth_code,
 260     int max_retries,
 261     Delegate* delegate) {
 262   return core_->GetTokensFromAuthCode(oauth_client_info,
 263                                       auth_code,
 264                                       max_retries,
 265                                       delegate);
 266 }
 267
 268 void GaiaOAuthClient::RefreshToken(const OAuthClientInfo& oauth_client_info,
 269                                    const std::string& refresh_token,
 270                                    int max_retries,
 271                                    Delegate* delegate) {
 272   return core_->RefreshToken(oauth_client_info,
 273                              refresh_token,
 274                              max_retries,
 275                              delegate);
 276 }
 277
 278 void GaiaOAuthClient::GetUserInfo(const std::string& access_token,
 279                                   int max_retries,
 280                                   Delegate* delegate) {
 281   return core_->GetUserInfo(access_token, max_retries, delegate);
 282 }
 283
 284 }  // namespace gaia