blob: 6076fec6c74afb26471a51a5e422e7a1de227560 [file] [log] [blame]
// Copyright 2017 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/oauth_multilogin_result.h"
#include "base/compiler_specific.h"
#include "base/json/json_reader.h"
#include "base/metrics/histogram_macros.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece_forward.h"
OAuthMultiloginResponseStatus ParseOAuthMultiloginResponseStatus(
const std::string& status) {
if (status == "OK")
return OAuthMultiloginResponseStatus::kOk;
if (status == "RETRY")
return OAuthMultiloginResponseStatus::kRetry;
if (status == "INVALID_TOKENS")
return OAuthMultiloginResponseStatus::kInvalidTokens;
if (status == "INVALID_INPUT")
return OAuthMultiloginResponseStatus::kInvalidInput;
if (status == "ERROR")
return OAuthMultiloginResponseStatus::kError;
return OAuthMultiloginResponseStatus::kUnknownStatus;
}
OAuthMultiloginResult::OAuthMultiloginResult(
const OAuthMultiloginResult& other) {
error_ = other.error();
cookies_ = other.cookies();
failed_accounts_ = other.failed_accounts();
}
OAuthMultiloginResult& OAuthMultiloginResult::operator=(
const OAuthMultiloginResult& other) {
error_ = other.error();
cookies_ = other.cookies();
failed_accounts_ = other.failed_accounts();
return *this;
}
OAuthMultiloginResult::OAuthMultiloginResult(
const GoogleServiceAuthError& error)
: error_(error) {}
void OAuthMultiloginResult::TryParseStatusFromValue(
base::DictionaryValue* dictionary_value) {
std::string status_string;
dictionary_value->GetString("status", &status_string);
OAuthMultiloginResponseStatus status =
ParseOAuthMultiloginResponseStatus(status_string);
UMA_HISTOGRAM_ENUMERATION("Signin.OAuthMultiloginResponseStatus", status);
switch (status) {
case OAuthMultiloginResponseStatus::kUnknownStatus:
error_ = GoogleServiceAuthError(
GoogleServiceAuthError::UNEXPECTED_SERVICE_RESPONSE);
break;
case OAuthMultiloginResponseStatus::kOk:
error_ = GoogleServiceAuthError::AuthErrorNone();
break;
case OAuthMultiloginResponseStatus::kRetry:
// This is a transient error.
error_ =
GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
break;
case OAuthMultiloginResponseStatus::kInvalidTokens:
error_ = GoogleServiceAuthError(
GoogleServiceAuthError::INVALID_GAIA_CREDENTIALS);
break;
case OAuthMultiloginResponseStatus::kError:
case OAuthMultiloginResponseStatus::kInvalidInput:
error_ = GoogleServiceAuthError(GoogleServiceAuthError::SERVICE_ERROR);
break;
}
}
// static
base::StringPiece OAuthMultiloginResult::StripXSSICharacters(
const std::string& raw_data) {
base::StringPiece body(raw_data);
return body.substr(body.find('\n'));
}
void OAuthMultiloginResult::TryParseFailedAccountsFromValue(
base::DictionaryValue* dictionary_value) {
base::ListValue* failed_accounts = nullptr;
dictionary_value->GetList("failed_accounts", &failed_accounts);
if (failed_accounts == nullptr) {
VLOG(1) << "No invalid accounts found in the response but error is set to "
"INVALID_TOKENS";
error_ = GoogleServiceAuthError(
GoogleServiceAuthError::UNEXPECTED_SERVICE_RESPONSE);
return;
}
for (size_t i = 0; i < failed_accounts->GetSize(); ++i) {
base::DictionaryValue* account_value = nullptr;
failed_accounts->GetDictionary(i, &account_value);
std::string gaia_id;
std::string status;
account_value->GetString("obfuscated_id", &gaia_id);
account_value->GetString("status", &status);
if (status != "OK")
failed_accounts_.push_back(gaia_id);
}
}
void OAuthMultiloginResult::TryParseCookiesFromValue(
base::DictionaryValue* dictionary_value) {
base::ListValue* cookie_list = nullptr;
dictionary_value->GetList("cookies", &cookie_list);
if (cookie_list == nullptr) {
VLOG(1) << "No cookies found in the response.";
error_ = GoogleServiceAuthError(
GoogleServiceAuthError::UNEXPECTED_SERVICE_RESPONSE);
return;
}
for (size_t i = 0; i < cookie_list->GetSize(); ++i) {
base::DictionaryValue* cookie_value = nullptr;
cookie_list->GetDictionary(i, &cookie_value);
std::string name;
std::string value;
std::string domain;
std::string host;
std::string path;
bool is_secure;
bool is_http_only;
std::string priority;
std::string max_age;
double expiration_delta;
cookie_value->GetString("name", &name);
cookie_value->GetString("value", &value);
cookie_value->GetString("domain", &domain);
cookie_value->GetString("host", &host);
cookie_value->GetString("path", &path);
cookie_value->GetBoolean("isSecure", &is_secure);
cookie_value->GetBoolean("isHttpOnly", &is_http_only);
cookie_value->GetString("priority", &priority);
cookie_value->GetDouble("maxAge", &expiration_delta);
base::TimeDelta before_expiration =
base::TimeDelta::FromSecondsD(expiration_delta);
if (domain.empty() && !host.empty() && host[0] != '.') {
// Host cookie case. If domain is empty but other conditions are not met,
// there must be something wrong with the received cookie.
domain = host;
}
net::CanonicalCookie new_cookie(
name, value, domain, path, base::Time::Now(),
base::Time::Now() + before_expiration, base::Time::Now(), is_secure,
is_http_only, net::CookieSameSite::NO_RESTRICTION,
net::StringToCookiePriority(priority));
if (new_cookie.IsCanonical()) {
cookies_.push_back(std::move(new_cookie));
} else {
LOG(ERROR) << "Non-canonical cookie found.";
}
}
}
OAuthMultiloginResult::OAuthMultiloginResult(const std::string& raw_data) {
base::StringPiece data = StripXSSICharacters(raw_data);
std::unique_ptr<base::DictionaryValue> dictionary_value =
base::DictionaryValue::From(base::JSONReader::Read(data));
if (!dictionary_value) {
error_ = GoogleServiceAuthError(
GoogleServiceAuthError::UNEXPECTED_SERVICE_RESPONSE);
return;
}
TryParseStatusFromValue(dictionary_value.get());
if (error_.state() == GoogleServiceAuthError::State::NONE) {
TryParseCookiesFromValue(dictionary_value.get());
} else if (error_.state() ==
GoogleServiceAuthError::State::INVALID_GAIA_CREDENTIALS) {
TryParseFailedAccountsFromValue(dictionary_value.get());
}
}
OAuthMultiloginResult::~OAuthMultiloginResult() = default;