google_apis/gaia/fake_gaia.cc - platform/external/chromium_org - Git at Google

 // Copyright (c) 2013 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/fake_gaia.h"

 #include "base/base_paths.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/values.h"
 #include "google_apis/gaia/gaia_urls.h"
 #include "net/base/url_util.h"
 #include "net/http/http_status_code.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "url/url_parse.h"

 using namespace net::test_server;

 namespace {
 const base::FilePath::CharType kServiceLogin[] =
     FILE_PATH_LITERAL("google_apis/test/service_login.html");
 }

 FakeGaia::AccessTokenInfo::AccessTokenInfo()
   : expires_in(3600) {}

 FakeGaia::AccessTokenInfo::~AccessTokenInfo() {}

 FakeGaia::FakeGaia() {
   base::FilePath source_root_dir;
   PathService::Get(base::DIR_SOURCE_ROOT, &source_root_dir);
   CHECK(base::ReadFileToString(
       source_root_dir.Append(base::FilePath(kServiceLogin)),
       &service_login_response_));
 }

 FakeGaia::~FakeGaia() {}

 scoped_ptr<HttpResponse> FakeGaia::HandleRequest(const HttpRequest& request) {
   GaiaUrls* gaia_urls = GaiaUrls::GetInstance();

   // The scheme and host of the URL is actually not important but required to
   // get a valid GURL in order to parse |request.relative_url|.
   GURL request_url = GURL("http://localhost").Resolve(request.relative_url);
   std::string request_path = request_url.path();

   scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
   if (request_path == gaia_urls->service_login_url().path()) {
     http_response->set_code(net::HTTP_OK);
     http_response->set_content(service_login_response_);
     http_response->set_content_type("text/html");
   } else if (request_path == gaia_urls->service_login_auth_url().path()) {
     std::string continue_url = gaia_urls->service_login_url().spec();
     GetQueryParameter(request.content, "continue", &continue_url);
     http_response->set_code(net::HTTP_OK);
     const std::string redirect_js =
         "document.location.href = '" + continue_url + "'";
     http_response->set_content(
         "<HTML><HEAD><SCRIPT>\n" + redirect_js + "\n</SCRIPT></HEAD></HTML>");
     http_response->set_content_type("text/html");
   } else if (request_path == gaia_urls->oauth2_token_url().path()) {
     std::string refresh_token;
     std::string client_id;
     std::string scope;
     const AccessTokenInfo* token_info = NULL;
     GetQueryParameter(request.content, "scope", &scope);
     if (GetQueryParameter(request.content, "refresh_token", &refresh_token) &&
         GetQueryParameter(request.content, "client_id", &client_id) &&
         (token_info = GetAccessTokenInfo(refresh_token, client_id, scope))) {
       base::DictionaryValue response_dict;
       response_dict.SetString("access_token", token_info->token);
       response_dict.SetInteger("expires_in", 3600);
       FormatJSONResponse(response_dict, http_response.get());
     } else {
       http_response->set_code(net::HTTP_BAD_REQUEST);
     }
   } else if (request_path == gaia_urls->oauth2_token_info_url().path()) {
     const AccessTokenInfo* token_info = NULL;
     std::string access_token;
     if (GetQueryParameter(request.content, "access_token", &access_token)) {
       for (AccessTokenInfoMap::const_iterator entry(
                access_token_info_map_.begin());
            entry != access_token_info_map_.end();
            ++entry) {
         if (entry->second.token == access_token) {
           token_info = &(entry->second);
           break;
         }
       }
     }

     if (token_info) {
       base::DictionaryValue response_dict;
       response_dict.SetString("issued_to", token_info->issued_to);
       response_dict.SetString("audience", token_info->audience);
       response_dict.SetString("user_id", token_info->user_id);
       std::vector<std::string> scope_vector(token_info->scopes.begin(),
                                             token_info->scopes.end());
       response_dict.SetString("scope", JoinString(scope_vector, " "));
       response_dict.SetInteger("expires_in", token_info->expires_in);
       response_dict.SetString("email", token_info->email);
       FormatJSONResponse(response_dict, http_response.get());
     } else {
       http_response->set_code(net::HTTP_BAD_REQUEST);
     }
   } else if (request_path == gaia_urls->oauth2_issue_token_url().path()) {
     std::string access_token;
     std::map<std::string, std::string>::const_iterator auth_header_entry =
         request.headers.find("Authorization");
     if (auth_header_entry != request.headers.end()) {
       if (StartsWithASCII(auth_header_entry->second, "Bearer ", true))
         access_token = auth_header_entry->second.substr(7);
     }

     std::string scope;
     std::string client_id;
     const AccessTokenInfo* token_info = NULL;
     if (GetQueryParameter(request.content, "scope", &scope) &&
         GetQueryParameter(request.content, "client_id", &client_id) &&
         (token_info = GetAccessTokenInfo(access_token, client_id, scope))) {
       base::DictionaryValue response_dict;
       response_dict.SetString("issueAdvice", "auto");
       response_dict.SetString("expiresIn",
                               base::IntToString(token_info->expires_in));
       response_dict.SetString("token", token_info->token);
       FormatJSONResponse(response_dict, http_response.get());
     } else {
       http_response->set_code(net::HTTP_BAD_REQUEST);
     }
   } else {
     // Request not understood.
     return scoped_ptr<HttpResponse>();
   }

   return http_response.PassAs<HttpResponse>();
 }

 void FakeGaia::IssueOAuthToken(const std::string& auth_token,
                                const AccessTokenInfo& token_info) {
   access_token_info_map_.insert(std::make_pair(auth_token, token_info));
 }

 void FakeGaia::FormatJSONResponse(const base::DictionaryValue& response_dict,
                                   BasicHttpResponse* http_response) {
   std::string response_json;
   base::JSONWriter::Write(&response_dict, &response_json);
   http_response->set_content(response_json);
   http_response->set_code(net::HTTP_OK);
 }

 const FakeGaia::AccessTokenInfo* FakeGaia::GetAccessTokenInfo(
     const std::string& auth_token,
     const std::string& client_id,
     const std::string& scope_string) const {
   if (auth_token.empty() || client_id.empty())
     return NULL;

   std::vector<std::string> scope_list;
   base::SplitString(scope_string, ' ', &scope_list);
   ScopeSet scopes(scope_list.begin(), scope_list.end());

   for (AccessTokenInfoMap::const_iterator entry(
            access_token_info_map_.lower_bound(auth_token));
        entry != access_token_info_map_.upper_bound(auth_token);
        ++entry) {
     if (entry->second.audience == client_id &&
         (scope_string.empty() || entry->second.scopes == scopes)) {
       return &(entry->second);
     }
   }

   return NULL;
 }

 // static
 bool FakeGaia::GetQueryParameter(const std::string& query,
                                  const std::string& key,
                                  std::string* value) {
   // Name and scheme actually don't matter, but are required to get a valid URL
   // for parsing.
   GURL query_url("http://localhost?" + query);
   return net::GetValueForKeyInQuery(query_url, key, value);
 }
	// Copyright (c) 2013 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/fake_gaia.h"

	#include "base/base_paths.h"
	#include "base/file_util.h"
	#include "base/files/file_path.h"
	#include "base/json/json_writer.h"
	#include "base/logging.h"
	#include "base/path_service.h"
	#include "base/strings/string_number_conversions.h"
	#include "base/strings/string_split.h"
	#include "base/strings/string_util.h"
	#include "base/values.h"
	#include "google_apis/gaia/gaia_urls.h"
	#include "net/base/url_util.h"
	#include "net/http/http_status_code.h"
	#include "net/test/embedded_test_server/http_request.h"
	#include "net/test/embedded_test_server/http_response.h"
	#include "url/url_parse.h"

	using namespace net::test_server;

	namespace {
	const base::FilePath::CharType kServiceLogin[] =
	FILE_PATH_LITERAL("google_apis/test/service_login.html");
	}

	FakeGaia::AccessTokenInfo::AccessTokenInfo()
	: expires_in(3600) {}

	FakeGaia::AccessTokenInfo::~AccessTokenInfo() {}

	FakeGaia::FakeGaia() {
	base::FilePath source_root_dir;
	PathService::Get(base::DIR_SOURCE_ROOT, &source_root_dir);
	CHECK(base::ReadFileToString(
	source_root_dir.Append(base::FilePath(kServiceLogin)),
	&service_login_response_));
	}

	FakeGaia::~FakeGaia() {}

	scoped_ptr<HttpResponse> FakeGaia::HandleRequest(const HttpRequest& request) {
	GaiaUrls* gaia_urls = GaiaUrls::GetInstance();

	// The scheme and host of the URL is actually not important but required to
	// get a valid GURL in order to parse \|request.relative_url\|.
	GURL request_url = GURL("http://localhost").Resolve(request.relative_url);
	std::string request_path = request_url.path();

	scoped_ptr<BasicHttpResponse> http_response(new BasicHttpResponse());
	if (request_path == gaia_urls->service_login_url().path()) {
	http_response->set_code(net::HTTP_OK);
	http_response->set_content(service_login_response_);
	http_response->set_content_type("text/html");
	} else if (request_path == gaia_urls->service_login_auth_url().path()) {
	std::string continue_url = gaia_urls->service_login_url().spec();
	GetQueryParameter(request.content, "continue", &continue_url);
	http_response->set_code(net::HTTP_OK);
	const std::string redirect_js =
	"document.location.href = '" + continue_url + "'";
	http_response->set_content(
	"<HTML><HEAD><SCRIPT>\n" + redirect_js + "\n</SCRIPT></HEAD></HTML>");
	http_response->set_content_type("text/html");
	} else if (request_path == gaia_urls->oauth2_token_url().path()) {
	std::string refresh_token;
	std::string client_id;
	std::string scope;
	const AccessTokenInfo* token_info = NULL;
	GetQueryParameter(request.content, "scope", &scope);
	if (GetQueryParameter(request.content, "refresh_token", &refresh_token) &&
	GetQueryParameter(request.content, "client_id", &client_id) &&
	(token_info = GetAccessTokenInfo(refresh_token, client_id, scope))) {
	base::DictionaryValue response_dict;
	response_dict.SetString("access_token", token_info->token);
	response_dict.SetInteger("expires_in", 3600);
	FormatJSONResponse(response_dict, http_response.get());
	} else {
	http_response->set_code(net::HTTP_BAD_REQUEST);
	}
	} else if (request_path == gaia_urls->oauth2_token_info_url().path()) {
	const AccessTokenInfo* token_info = NULL;
	std::string access_token;
	if (GetQueryParameter(request.content, "access_token", &access_token)) {
	for (AccessTokenInfoMap::const_iterator entry(
	access_token_info_map_.begin());
	entry != access_token_info_map_.end();
	++entry) {
	if (entry->second.token == access_token) {
	token_info = &(entry->second);
	break;
	}
	}
	}

	if (token_info) {
	base::DictionaryValue response_dict;
	response_dict.SetString("issued_to", token_info->issued_to);
	response_dict.SetString("audience", token_info->audience);
	response_dict.SetString("user_id", token_info->user_id);
	std::vector<std::string> scope_vector(token_info->scopes.begin(),
	token_info->scopes.end());
	response_dict.SetString("scope", JoinString(scope_vector, " "));
	response_dict.SetInteger("expires_in", token_info->expires_in);
	response_dict.SetString("email", token_info->email);
	FormatJSONResponse(response_dict, http_response.get());
	} else {
	http_response->set_code(net::HTTP_BAD_REQUEST);
	}
	} else if (request_path == gaia_urls->oauth2_issue_token_url().path()) {
	std::string access_token;
	std::map<std::string, std::string>::const_iterator auth_header_entry =
	request.headers.find("Authorization");
	if (auth_header_entry != request.headers.end()) {
	if (StartsWithASCII(auth_header_entry->second, "Bearer ", true))
	access_token = auth_header_entry->second.substr(7);
	}

	std::string scope;
	std::string client_id;
	const AccessTokenInfo* token_info = NULL;
	if (GetQueryParameter(request.content, "scope", &scope) &&
	GetQueryParameter(request.content, "client_id", &client_id) &&
	(token_info = GetAccessTokenInfo(access_token, client_id, scope))) {
	base::DictionaryValue response_dict;
	response_dict.SetString("issueAdvice", "auto");
	response_dict.SetString("expiresIn",
	base::IntToString(token_info->expires_in));
	response_dict.SetString("token", token_info->token);
	FormatJSONResponse(response_dict, http_response.get());
	} else {
	http_response->set_code(net::HTTP_BAD_REQUEST);
	}
	} else {
	// Request not understood.
	return scoped_ptr<HttpResponse>();
	}

	return http_response.PassAs<HttpResponse>();
	}

	void FakeGaia::IssueOAuthToken(const std::string& auth_token,
	const AccessTokenInfo& token_info) {
	access_token_info_map_.insert(std::make_pair(auth_token, token_info));
	}

	void FakeGaia::FormatJSONResponse(const base::DictionaryValue& response_dict,
	BasicHttpResponse* http_response) {
	std::string response_json;
	base::JSONWriter::Write(&response_dict, &response_json);
	http_response->set_content(response_json);
	http_response->set_code(net::HTTP_OK);
	}

	const FakeGaia::AccessTokenInfo* FakeGaia::GetAccessTokenInfo(
	const std::string& auth_token,
	const std::string& client_id,
	const std::string& scope_string) const {
	if (auth_token.empty() \|\| client_id.empty())
	return NULL;

	std::vector<std::string> scope_list;
	base::SplitString(scope_string, ' ', &scope_list);
	ScopeSet scopes(scope_list.begin(), scope_list.end());

	for (AccessTokenInfoMap::const_iterator entry(
	access_token_info_map_.lower_bound(auth_token));
	entry != access_token_info_map_.upper_bound(auth_token);
	++entry) {
	if (entry->second.audience == client_id &&
	(scope_string.empty() \|\| entry->second.scopes == scopes)) {
	return &(entry->second);
	}
	}

	return NULL;
	}

	// static
	bool FakeGaia::GetQueryParameter(const std::string& query,
	const std::string& key,
	std::string* value) {
	// Name and scheme actually don't matter, but are required to get a valid URL
	// for parsing.
	GURL query_url("http://localhost?" + query);
	return net::GetValueForKeyInQuery(query_url, key, value);
	}