blob: f1c7203576971d2eb6000efe58da5476ed2f180b [file] [log] [blame]
// 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/drive/auth_service.h"
#include <string>
#include <vector>
#include "base/bind.h"
#include "base/location.h"
#include "base/macros.h"
#include "base/metrics/histogram_macros.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
#include "google_apis/drive/auth_service_observer.h"
#include "google_apis/gaia/google_service_auth_error.h"
#include "net/url_request/url_request_context_getter.h"
namespace google_apis {
namespace {
// Used for success ratio histograms. 0 for failure, 1 for success,
// 2 for no connection (likely offline).
const int kSuccessRatioHistogramFailure = 0;
const int kSuccessRatioHistogramSuccess = 1;
const int kSuccessRatioHistogramNoConnection = 2;
const int kSuccessRatioHistogramTemporaryFailure = 3;
const int kSuccessRatioHistogramMaxValue = 4; // The max value is exclusive.
void RecordAuthResultHistogram(int value) {
UMA_HISTOGRAM_ENUMERATION("GData.AuthSuccess",
value,
kSuccessRatioHistogramMaxValue);
}
// OAuth2 authorization token retrieval request.
class AuthRequest : public OAuth2TokenService::Consumer {
public:
AuthRequest(OAuth2TokenService* oauth2_token_service,
const std::string& account_id,
net::URLRequestContextGetter* url_request_context_getter,
const AuthStatusCallback& callback,
const std::vector<std::string>& scopes);
~AuthRequest() override;
private:
// Overridden from OAuth2TokenService::Consumer:
void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
const std::string& access_token,
const base::Time& expiration_time) override;
void OnGetTokenFailure(const OAuth2TokenService::Request* request,
const GoogleServiceAuthError& error) override;
AuthStatusCallback callback_;
std::unique_ptr<OAuth2TokenService::Request> request_;
base::ThreadChecker thread_checker_;
DISALLOW_COPY_AND_ASSIGN(AuthRequest);
};
AuthRequest::AuthRequest(
OAuth2TokenService* oauth2_token_service,
const std::string& account_id,
net::URLRequestContextGetter* url_request_context_getter,
const AuthStatusCallback& callback,
const std::vector<std::string>& scopes)
: OAuth2TokenService::Consumer("auth_service"),
callback_(callback) {
DCHECK(!callback_.is_null());
request_ = oauth2_token_service->
StartRequestWithContext(
account_id,
url_request_context_getter,
OAuth2TokenService::ScopeSet(scopes.begin(), scopes.end()),
this);
}
AuthRequest::~AuthRequest() {}
// Callback for OAuth2AccessTokenFetcher on success. |access_token| is the token
// used to start fetching user data.
void AuthRequest::OnGetTokenSuccess(const OAuth2TokenService::Request* request,
const std::string& access_token,
const base::Time& expiration_time) {
DCHECK(thread_checker_.CalledOnValidThread());
RecordAuthResultHistogram(kSuccessRatioHistogramSuccess);
callback_.Run(HTTP_SUCCESS, access_token);
delete this;
}
// Callback for OAuth2AccessTokenFetcher on failure.
void AuthRequest::OnGetTokenFailure(const OAuth2TokenService::Request* request,
const GoogleServiceAuthError& error) {
DCHECK(thread_checker_.CalledOnValidThread());
LOG(WARNING) << "AuthRequest: token request using refresh token failed: "
<< error.ToString();
// There are many ways to fail, but if the failure is due to connection,
// it's likely that the device is off-line. We treat the error differently
// so that the file manager works while off-line.
if (error.state() == GoogleServiceAuthError::CONNECTION_FAILED) {
RecordAuthResultHistogram(kSuccessRatioHistogramNoConnection);
callback_.Run(DRIVE_NO_CONNECTION, std::string());
} else if (error.state() == GoogleServiceAuthError::SERVICE_UNAVAILABLE) {
RecordAuthResultHistogram(kSuccessRatioHistogramTemporaryFailure);
callback_.Run(HTTP_FORBIDDEN, std::string());
} else {
// Permanent auth error.
RecordAuthResultHistogram(kSuccessRatioHistogramFailure);
callback_.Run(HTTP_UNAUTHORIZED, std::string());
}
delete this;
}
} // namespace
AuthService::AuthService(
OAuth2TokenService* oauth2_token_service,
const std::string& account_id,
net::URLRequestContextGetter* url_request_context_getter,
const std::vector<std::string>& scopes)
: oauth2_token_service_(oauth2_token_service),
account_id_(account_id),
url_request_context_getter_(url_request_context_getter),
scopes_(scopes),
weak_ptr_factory_(this) {
DCHECK(oauth2_token_service);
// Get OAuth2 refresh token (if we have any) and register for its updates.
oauth2_token_service_->AddObserver(this);
has_refresh_token_ = oauth2_token_service_->RefreshTokenIsAvailable(
account_id_);
}
AuthService::~AuthService() {
oauth2_token_service_->RemoveObserver(this);
}
void AuthService::StartAuthentication(const AuthStatusCallback& callback) {
DCHECK(thread_checker_.CalledOnValidThread());
if (HasAccessToken()) {
// We already have access token. Give it back to the caller asynchronously.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(callback, HTTP_SUCCESS, access_token_));
} else if (HasRefreshToken()) {
// We have refresh token, let's get an access token.
new AuthRequest(oauth2_token_service_,
account_id_,
url_request_context_getter_.get(),
base::Bind(&AuthService::OnAuthCompleted,
weak_ptr_factory_.GetWeakPtr(),
callback),
scopes_);
} else {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(callback, DRIVE_NOT_READY, std::string()));
}
}
bool AuthService::HasAccessToken() const {
return !access_token_.empty();
}
bool AuthService::HasRefreshToken() const {
return has_refresh_token_;
}
const std::string& AuthService::access_token() const {
return access_token_;
}
void AuthService::ClearAccessToken() {
access_token_.clear();
}
void AuthService::ClearRefreshToken() {
OnHandleRefreshToken(false);
}
void AuthService::OnAuthCompleted(const AuthStatusCallback& callback,
DriveApiErrorCode error,
const std::string& access_token) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(!callback.is_null());
if (error == HTTP_SUCCESS) {
access_token_ = access_token;
} else if (error == HTTP_UNAUTHORIZED) {
// Refreshing access token using the refresh token is failed with 401 error
// (HTTP_UNAUTHORIZED). This means the current refresh token is invalid for
// Drive, hence we clear the refresh token here to make HasRefreshToken()
// false, thus the invalidness is clearly observable.
// This is not for triggering refetch of the refresh token. UI should
// show some message to encourage user to log-off and log-in again in order
// to fetch new valid refresh token.
ClearRefreshToken();
}
callback.Run(error, access_token);
}
void AuthService::AddObserver(AuthServiceObserver* observer) {
observers_.AddObserver(observer);
}
void AuthService::RemoveObserver(AuthServiceObserver* observer) {
observers_.RemoveObserver(observer);
}
void AuthService::OnRefreshTokenAvailable(const std::string& account_id) {
if (account_id == account_id_)
OnHandleRefreshToken(true);
}
void AuthService::OnRefreshTokenRevoked(const std::string& account_id) {
if (account_id == account_id_)
OnHandleRefreshToken(false);
}
void AuthService::OnHandleRefreshToken(bool has_refresh_token) {
access_token_.clear();
has_refresh_token_ = has_refresh_token;
for (auto& observer : observers_)
observer.OnOAuth2RefreshTokenChanged();
}
} // namespace google_apis