Allow passing in a list of scopes to the access token fetcher class.

chrome/common/net/gaia/oauth2_access_token_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/common/net/gaia/oauth2_access_token_fetcher.h"
 
 #include <algorithm>
 #include <string>
+#include <vector>
 
 #include "base/json/json_reader.h"
+#include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/common/net/gaia/gaia_urls.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/net/http_return.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "net/url_request/url_request_status.h"
 
 using content::URLFetcher;
 using content::URLFetcherDelegate;
 using net::ResponseCookies;
 using net::URLRequestContextGetter;
 using net::URLRequestStatus;
 
 namespace {
 static const char kGetAccessTokenBodyFormat[] =
     "client_id=%s&"
-    "client_secret=%s"
+    "client_secret=%s&"
     "grant_type=refresh_token&"
     "refresh_token=%s";
 
+static const char kGetAccessTokenBodyWithScopeFormat[] =
+    "client_id=%s&"
+    "client_secret=%s&"
+    "grant_type=refresh_token&"
+    "refresh_token=%s&"
+    "scope=%s";
+
 static const char kAccessTokenKey[] = "access_token";
 
 static bool GetStringFromDictionary(const DictionaryValue* dict,
                                     const std::string& key,
                                     std::string* value) {
   Value* json_value;
   if (!dict->Get(key, &json_value))
     return false;
   if (json_value->GetType() != base::Value::TYPE_STRING)
     return false;
@@ skipping 30 matching lines @@
 
   if (!empty_body)
     result->SetUploadData("application/x-www-form-urlencoded", body);
 
   return result;
 }
 }  // namespace
 
 OAuth2AccessTokenFetcher::OAuth2AccessTokenFetcher(
     OAuth2AccessTokenConsumer* consumer,
-    URLRequestContextGetter* getter,
-    const std::string& source)
+    URLRequestContextGetter* getter)
     : consumer_(consumer),
       getter_(getter),
-      source_(source),
       state_(INITIAL) { }
 
 OAuth2AccessTokenFetcher::~OAuth2AccessTokenFetcher() { }
 
 void OAuth2AccessTokenFetcher::CancelRequest() {
   fetcher_.reset();
 }
 
 void OAuth2AccessTokenFetcher::Start(const std::string& client_id,
                                      const std::string& client_secret,
-                                     const std::string& refresh_token) {
+                                     const std::string& refresh_token,
+                                     const std::vector<std::string>& scopes) {
   client_id_ = client_id;
   client_secret_ = client_secret;
   refresh_token_ = refresh_token;
+  scopes_ = scopes;
   StartGetAccessToken();
 }
 
 void OAuth2AccessTokenFetcher::StartGetAccessToken() {
   CHECK_EQ(INITIAL, state_);
   state_ = GET_ACCESS_TOKEN_STARTED;
   fetcher_.reset(CreateFetcher(
       getter_,
       MakeGetAccessTokenUrl(),
-      MakeGetAccessTokenBody(client_id_, client_secret_, refresh_token_),
+      MakeGetAccessTokenBody(
+          client_id_, client_secret_, refresh_token_, scopes_),
       this));
   fetcher_->Start();  // OnURLFetchComplete will be called.
 }
 
 void OAuth2AccessTokenFetcher::EndGetAccessToken(const URLFetcher* source) {
   CHECK_EQ(GET_ACCESS_TOKEN_STARTED, state_);
   state_ = GET_ACCESS_TOKEN_DONE;
 
   URLRequestStatus status = source->GetStatus();
   if (!status.is_success()) {
@@ skipping 32 matching lines @@
 
 // static
 GURL OAuth2AccessTokenFetcher::MakeGetAccessTokenUrl() {
   return GURL(GaiaUrls::GetInstance()->oauth2_token_url());
 }
 
 // static
 std::string OAuth2AccessTokenFetcher::MakeGetAccessTokenBody(
     const std::string& client_id,
     const std::string& client_secret,
-    const std::string& refresh_token) {
-  return StringPrintf(
-      kGetAccessTokenBodyFormat,
-      net::EscapeUrlEncodedData(client_id, true).c_str(),
-      net::EscapeUrlEncodedData(client_secret, true).c_str(),
-      net::EscapeUrlEncodedData(refresh_token, true).c_str());
+    const std::string& refresh_token,
+    const std::vector<std::string>& scopes) {
+  std::string enc_client_id = net::EscapeUrlEncodedData(client_id, true);
+  std::string enc_client_secret =
+      net::EscapeUrlEncodedData(client_secret, true);
+  std::string enc_refresh_token =
+      net::EscapeUrlEncodedData(refresh_token, true);
+  if (scopes.empty()) {
+    return StringPrintf(
+        kGetAccessTokenBodyFormat,
+        enc_client_id.c_str(),
+        enc_client_secret.c_str(),
+        enc_refresh_token.c_str());
+  } else {
+    std::string scopes_string = JoinString(scopes, ',');
+    return StringPrintf(
+        kGetAccessTokenBodyWithScopeFormat,
+        enc_client_id.c_str(),
+        enc_client_secret.c_str(),
+        enc_refresh_token.c_str(),
+        net::EscapeUrlEncodedData(scopes_string, true).c_str());
+  }
 }
 
 // static
 bool OAuth2AccessTokenFetcher::ParseGetAccessTokenResponse(
     const URLFetcher* source,
     std::string* access_token) {
   CHECK(source);
   CHECK(access_token);
   std::string data;
   source->GetResponseAsString(&data);
   base::JSONReader reader;
   scoped_ptr<base::Value> value(reader.Read(data, false));
   if (!value.get() || value->GetType() != base::Value::TYPE_DICTIONARY)
     return false;
 
   DictionaryValue* dict = static_cast<DictionaryValue*>(value.get());
   return GetStringFromDictionary(dict, kAccessTokenKey, access_token);
 }