Identity API: Add token cache and identity.invalidateAuthToken.

google_apis/gaia/oauth2_mint_token_flow.cc

 // Copyright (c) 2012 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 "google_apis/gaia/oauth2_mint_token_flow.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using net::URLFetcher;
@@ skipping 11 matching lines @@
     "force=%s"
     "&response_type=%s"
     "&scope=%s"
     "&client_id=%s"
     "&origin=%s";
 static const char kIssueAdviceKey[] = "issueAdvice";
 static const char kIssueAdviceValueAuto[] = "auto";
 static const char kIssueAdviceValueConsent[] = "consent";
 static const char kAccessTokenKey[] = "token";
 static const char kConsentKey[] = "consent";
+static const char kExpiresInKey[] = "expiresIn";
 static const char kScopesKey[] = "scopes";
 static const char kDescriptionKey[] = "description";
 static const char kDetailKey[] = "detail";
 static const char kDetailSeparators[] = "\n";
 
 static GoogleServiceAuthError CreateAuthError(URLRequestStatus status) {
   if (status.status() == URLRequestStatus::CANCELED) {
     return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED);
   } else {
     // TODO(munjal): Improve error handling. Currently we return connection
@@ skipping 37 matching lines @@
     : OAuth2ApiCallFlow(context,
                         parameters.login_refresh_token,
                         std::string(),
                         std::vector<std::string>()),
       delegate_(delegate),
       parameters_(parameters),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
 
 OAuth2MintTokenFlow::~OAuth2MintTokenFlow() { }
 
-void OAuth2MintTokenFlow::ReportSuccess(const std::string& access_token) {
+void OAuth2MintTokenFlow::ReportSuccess(const std::string& access_token,
+                                        int time_to_live) {
   if (delegate_)
-    delegate_->OnMintTokenSuccess(access_token);
+    delegate_->OnMintTokenSuccess(access_token, time_to_live);
 
   // |this| may already be deleted.
 }
 
 void OAuth2MintTokenFlow::ReportIssueAdviceSuccess(
     const IssueAdviceInfo& issue_advice) {
   if (delegate_)
     delegate_->OnIssueAdviceSuccess(issue_advice);
 
   // |this| may already be deleted.
@@ skipping 49 matching lines @@
     return;
   }
   if (issue_advice == kIssueAdviceValueConsent) {
     IssueAdviceInfo issue_advice;
     if (ParseIssueAdviceResponse(dict, &issue_advice))
       ReportIssueAdviceSuccess(issue_advice);
     else
       ReportFailure(GoogleServiceAuthError::FromConnectionError(101));
   } else {
     std::string access_token;
-    if (ParseMintTokenResponse(dict, &access_token))
-      ReportSuccess(access_token);
+    int time_to_live;
+    if (ParseMintTokenResponse(dict, &access_token, &time_to_live))
+      ReportSuccess(access_token, time_to_live);
     else
       ReportFailure(GoogleServiceAuthError::FromConnectionError(101));
   }
 
   // |this| may be deleted!
 }
 
 void OAuth2MintTokenFlow::ProcessApiCallFailure(
     const net::URLFetcher* source) {
   ReportFailure(CreateAuthError(source->GetStatus()));
 }
 void OAuth2MintTokenFlow::ProcessNewAccessToken(
     const std::string& access_token) {
   // We don't currently store new access tokens. We generate one every time.
   // So we have nothing to do here.
   return;
 }
 void OAuth2MintTokenFlow::ProcessMintAccessTokenFailure(
     const GoogleServiceAuthError& error) {
   ReportFailure(error);
 }
 
 // static
 bool OAuth2MintTokenFlow::ParseMintTokenResponse(
-    const base::DictionaryValue* dict, std::string* access_token) {
+    const base::DictionaryValue* dict, std::string* access_token,
+    int* time_to_live) {
   CHECK(dict);
   CHECK(access_token);
-  return dict->GetString(kAccessTokenKey, access_token);
+  CHECK(time_to_live);
+  std::string ttl_string;
+  return dict->GetString(kExpiresInKey, &ttl_string) &&
+      base::StringToInt(ttl_string, time_to_live) &&
+      dict->GetString(kAccessTokenKey, access_token);
 }
 
 // static
 bool OAuth2MintTokenFlow::ParseIssueAdviceResponse(
     const base::DictionaryValue* dict, IssueAdviceInfo* issue_advice) {
   CHECK(dict);
   CHECK(issue_advice);
 
   const base::DictionaryValue* consent_dict = NULL;
   if (!dict->GetDictionary(kConsentKey, &consent_dict))
@@ skipping 21 matching lines @@
     for (size_t i = 0; i < entry.details.size(); i++)
       TrimWhitespace(entry.details[i], TRIM_ALL, &entry.details[i]);
     issue_advice->push_back(entry);
   }
 
   if (!success)
     issue_advice->clear();
 
   return success;
 }