Merge 103908 - Extend GaiaOAuthFetcher with support for revoking tokens.

chrome/browser/net/gaia/gaia_oauth_fetcher.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/net/gaia/gaia_oauth_fetcher.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 31 matching lines @@
 
 static const char kOAuthWrapBridgeUserInfoScope[] =
     "https://www.googleapis.com/auth/userinfo.email";
 
 static const char kOAuth1LoginScope[] =
     "https://www.google.com/accounts/OAuthLogin";
 
 static const char kUserInfoUrl[] =
     "https://www.googleapis.com/oauth2/v1/userinfo";
 
+static const char kRevokeTokenUrl[] =
+    "https://www.google.com/accounts/AuthSubRevokeToken";
+
 static const char kOAuthTokenCookie[] = "oauth_token";
 
 GaiaOAuthFetcher::GaiaOAuthFetcher(GaiaOAuthConsumer* consumer,
                                    net::URLRequestContextGetter* getter,
                                    Profile* profile,
                                    const std::string& service_scope)
     : consumer_(consumer),
       getter_(getter),
       profile_(profile),
       popup_(NULL),
@@ skipping 57 matching lines @@
 // static
 std::string GaiaOAuthFetcher::MakeOAuthLoginBody(
     const char* source,
     const char* service,
     const std::string& oauth1_access_token,
     const std::string& oauth1_access_token_secret) {
   OAuthRequestSigner::Parameters parameters;
   parameters["service"] = service;
   parameters["source"] = source;
   std::string signed_request;
-  bool is_signed = OAuthRequestSigner::Sign(
+  bool is_signed = OAuthRequestSigner::SignURL(
       GURL(kOAuth1LoginScope),
       parameters,
       OAuthRequestSigner::HMAC_SHA1_SIGNATURE,
       OAuthRequestSigner::POST_METHOD,
       "anonymous",  // oauth_consumer_key
       "anonymous",  // consumer secret
       oauth1_access_token,  // oauth_token
       oauth1_access_token_secret,  // token secret
       &signed_request);
   DCHECK(is_signed);
   return signed_request;
 }
 
 // static
 std::string GaiaOAuthFetcher::MakeOAuthGetAccessTokenBody(
     const std::string& oauth1_request_token) {
   OAuthRequestSigner::Parameters empty_parameters;
   std::string signed_request;
-  bool is_signed = OAuthRequestSigner::Sign(
+  bool is_signed = OAuthRequestSigner::SignURL(
       GURL(kOAuthGetAccessTokenUrl),
       empty_parameters,
       OAuthRequestSigner::HMAC_SHA1_SIGNATURE,
       OAuthRequestSigner::POST_METHOD,
       "anonymous",  // oauth_consumer_key
       "anonymous",  // consumer secret
       oauth1_request_token,  // oauth_token
       "",  // token secret
       &signed_request);
   DCHECK(is_signed);
   return signed_request;
 }
 
 // static
 std::string GaiaOAuthFetcher::MakeOAuthWrapBridgeBody(
     const std::string& oauth1_access_token,
     const std::string& oauth1_access_token_secret,
     const std::string& wrap_token_duration,
     const std::string& oauth2_scope) {
   OAuthRequestSigner::Parameters parameters;
   parameters["wrap_token_duration"] = wrap_token_duration;
   parameters["wrap_scope"] = oauth2_scope;
   std::string signed_request;
-  bool is_signed = OAuthRequestSigner::Sign(
+  bool is_signed = OAuthRequestSigner::SignURL(
       GURL(kOAuthWrapBridgeUrl),
       parameters,
       OAuthRequestSigner::HMAC_SHA1_SIGNATURE,
       OAuthRequestSigner::POST_METHOD,
       "anonymous",  // oauth_consumer_key
       "anonymous",  // consumer secret
       oauth1_access_token,  // oauth_token
       oauth1_access_token_secret,  // token secret
       &signed_request);
   DCHECK(is_signed);
@@ skipping 257 matching lines @@
   fetcher_.reset(CreateGaiaFetcher(getter_,
                                    GURL(kUserInfoUrl),
                                    request_body_,
                                    request_headers_,
                                    false,
                                    this));
   fetch_pending_ = true;
   fetcher_->Start();
 }
 
+void GaiaOAuthFetcher::StartOAuthRevokeAccessToken(const std::string& token,
+                                                   const std::string& secret) {
+  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+
+  // Must outlive fetcher_.
+  request_body_ = "";
+
+  OAuthRequestSigner::Parameters empty_parameters;
+  std::string auth_header;
+  GURL url(kRevokeTokenUrl);
+  bool is_signed = OAuthRequestSigner::SignAuthHeader(
+      url,
+      empty_parameters,
+      OAuthRequestSigner::HMAC_SHA1_SIGNATURE,
+      OAuthRequestSigner::GET_METHOD,
+      "anonymous",
+      "anonymous",
+      token,
+      secret,
+      &auth_header);
+  DCHECK(is_signed);
+  request_headers_ = "Authorization: " + auth_header;
+  fetcher_.reset(CreateGaiaFetcher(getter_, url, request_body_,
+                                   request_headers_, false, this));
+  fetch_pending_ = true;
+  fetcher_->Start();
+}
+
+void GaiaOAuthFetcher::StartOAuthRevokeWrapToken(const std::string& token) {
+  DCHECK(!fetch_pending_) << "Tried to fetch two things at once!";
+
+  // Must outlive fetcher_.
+  request_body_ = "";
+
+  request_headers_ = "Authorization: Bearer " + token;
+  GURL url(kRevokeTokenUrl);
+  fetcher_.reset(CreateGaiaFetcher(getter_, url, request_body_,
+                                   request_headers_, false, this));
+  fetch_pending_ = true;
+  fetcher_->Start();
+}
+
 // static
 GoogleServiceAuthError GaiaOAuthFetcher::GenerateAuthError(
     const std::string& data,
     const net::URLRequestStatus& status) {
   if (!status.is_success()) {
     if (status.status() == net::URLRequestStatus::CANCELED) {
       return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
     } else {
       LOG(WARNING) << "Could not reach Google Accounts servers: errno "
                    << status.os_error();
@@ skipping 150 matching lines @@
     ParseOAuthWrapBridgeResponse(data, &token, &expires_in);
     consumer_->OnOAuthWrapBridgeSuccess(service_scope_, token, expires_in);
     if (ShouldAutoFetch(USER_INFO))
       StartUserInfo(token);
   } else {
     consumer_->OnOAuthWrapBridgeFailure(service_scope_,
                                         GenerateAuthError(data, status));
   }
 }
 
+void GaiaOAuthFetcher::OnOAuthRevokeTokenFetched(
+    const std::string& data,
+    const net::URLRequestStatus& status,
+    int response_code) {
+  if (status.is_success() && response_code == RC_REQUEST_OK) {
+    consumer_->OnOAuthRevokeTokenSuccess();
+  } else {
+    LOG(ERROR) << "Token revocation failure " << response_code << ": " << data;
+    consumer_->OnOAuthRevokeTokenFailure(GenerateAuthError(data, status));
+  }
+}
+
 void GaiaOAuthFetcher::OnUserInfoFetched(
     const std::string& data,
     const net::URLRequestStatus& status,
     int response_code) {
   if (status.is_success() && response_code == RC_REQUEST_OK) {
     std::string email;
     ParseUserInfoResponse(data, &email);
     VLOG(1) << "GAIA user info fetched for " << email << ".";
     consumer_->OnUserInfoSuccess(email);
   } else {
@@ skipping 13 matching lines @@
   if (StartsWithASCII(url.spec(), kGetOAuthTokenUrl, true)) {
     OnGetOAuthTokenUrlFetched(cookies, status, response_code);
   } else if (url.spec() == kOAuth1LoginScope) {
     OnOAuthLoginFetched(data, status, response_code);
   } else if (url.spec() == kOAuthGetAccessTokenUrl) {
     OnOAuthGetAccessTokenFetched(data, status, response_code);
   } else if (url.spec() == kOAuthWrapBridgeUrl) {
     OnOAuthWrapBridgeFetched(data, status, response_code);
   } else if (url.spec() == kUserInfoUrl) {
     OnUserInfoFetched(data, status, response_code);
+  } else if (StartsWithASCII(url.spec(), kRevokeTokenUrl, true)) {
+    OnOAuthRevokeTokenFetched(data, status, response_code);
   } else {
     NOTREACHED();
   }
 }
 
 bool GaiaOAuthFetcher::ShouldAutoFetch(AutoFetchLimit fetch_step) {
   return fetch_step <= auto_fetch_limit_;
 }