| // 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 "chrome/browser/extensions/api/push_messaging/obfuscated_gaia_id_fetcher.h" |
| |
| #include <vector> |
| |
| #include "base/json/json_reader.h" |
| #include "base/values.h" |
| #include "google_apis/gaia/google_service_auth_error.h" |
| #include "net/url_request/url_fetcher.h" |
| #include "net/url_request/url_request_status.h" |
| |
| using net::URLFetcher; |
| using net::URLRequestContextGetter; |
| using net::URLRequestStatus; |
| |
| namespace { |
| |
| // URL of the service to get obfuscated Gaia ID (here misnamed channel ID). |
| static const char kCWSChannelServiceURL[] = |
| "https://www.googleapis.com/gcm_for_chrome/v1/channels/id"; |
| |
| GoogleServiceAuthError CreateAuthError(const URLFetcher* source) { |
| if (source->GetStatus().status() == URLRequestStatus::CANCELED) { |
| return GoogleServiceAuthError(GoogleServiceAuthError::REQUEST_CANCELED); |
| } else { |
| // TODO(munjal): Improve error handling. Currently we return connection |
| // error for even application level errors. We need to either expand the |
| // GoogleServiceAuthError enum or create a new one to report better |
| // errors. |
| if (source->GetStatus().is_success()) { |
| DLOG(WARNING) << "Remote server returned " << source->GetResponseCode(); |
| return GoogleServiceAuthError::FromConnectionError( |
| source->GetResponseCode()); |
| } else { |
| DLOG(WARNING) << "URLFetcher failed: " << source->GetStatus().error(); |
| return GoogleServiceAuthError::FromConnectionError( |
| source->GetStatus().error()); |
| } |
| } |
| } |
| |
| } // namespace |
| |
| namespace extensions { |
| |
| ObfuscatedGaiaIdFetcher::ObfuscatedGaiaIdFetcher( |
| URLRequestContextGetter* context, |
| Delegate* delegate, |
| const std::string& access_token) |
| : OAuth2ApiCallFlow(context, std::string(), access_token, GetScopes()), |
| delegate_(delegate) { |
| DCHECK(delegate); |
| } |
| |
| ObfuscatedGaiaIdFetcher::~ObfuscatedGaiaIdFetcher() { } |
| |
| // Returns a vector of scopes needed to call the API to get obfuscated Gaia ID. |
| std::vector<std::string> ObfuscatedGaiaIdFetcher::GetScopes() { |
| std::vector<std::string> scopes; |
| scopes.push_back("https://www.googleapis.com/auth/gcm_for_chrome.readonly"); |
| return scopes; |
| } |
| |
| void ObfuscatedGaiaIdFetcher::ReportSuccess(const std::string& obfuscated_id) { |
| if (delegate_) |
| delegate_->OnObfuscatedGaiaIdFetchSuccess(obfuscated_id); |
| } |
| |
| void ObfuscatedGaiaIdFetcher::ReportFailure( |
| const GoogleServiceAuthError& error) { |
| if (delegate_) |
| delegate_->OnObfuscatedGaiaIdFetchFailure(error); |
| } |
| |
| GURL ObfuscatedGaiaIdFetcher::CreateApiCallUrl() { |
| return GURL(kCWSChannelServiceURL); |
| } |
| |
| std::string ObfuscatedGaiaIdFetcher::CreateApiCallBody() { |
| // Nothing to do here, we don't need a body for this request, the URL |
| // encodes all the proper arguments. |
| return std::string(); |
| } |
| |
| void ObfuscatedGaiaIdFetcher::ProcessApiCallSuccess( |
| const net::URLFetcher* source) { |
| // TODO(munjal): Change error code paths in this method to report an |
| // internal error. |
| std::string response_body; |
| CHECK(source->GetResponseAsString(&response_body)); |
| |
| std::string obfuscated_id; |
| if (ParseResponse(response_body, &obfuscated_id)) |
| ReportSuccess(obfuscated_id); |
| else |
| // we picked 101 arbitrarily to help us correlate the error with this code. |
| ReportFailure(GoogleServiceAuthError::FromConnectionError(101)); |
| } |
| |
| void ObfuscatedGaiaIdFetcher::ProcessApiCallFailure( |
| const net::URLFetcher* source) { |
| ReportFailure(CreateAuthError(source)); |
| } |
| |
| void ObfuscatedGaiaIdFetcher::ProcessNewAccessToken( |
| const std::string& obfuscated_id) { |
| // We generate a new access token every time instead of storing the access |
| // token since access tokens expire every hour and we expect to get |
| // obfuscated Gaia ID very infrequently. |
| } |
| |
| void ObfuscatedGaiaIdFetcher::ProcessMintAccessTokenFailure( |
| const GoogleServiceAuthError& error) { |
| // We failed to generate the token needed to call the API to get |
| // the obfuscated Gaia ID, so report failure to the caller. |
| ReportFailure(error); |
| } |
| |
| // static |
| bool ObfuscatedGaiaIdFetcher::ParseResponse( |
| const std::string& data, std::string* result) { |
| scoped_ptr<base::Value> value(base::JSONReader::Read(data)); |
| |
| if (!value.get()) |
| return false; |
| |
| base::DictionaryValue* dict = NULL; |
| if (!value->GetAsDictionary(&dict)) |
| return false; |
| |
| return dict->GetString("id", result); |
| } |
| |
| } // namespace extensions |