google_apis/gcm/engine/registration_request.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "google_apis/gcm/engine/registration_request.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9 #include "base/metrics/histogram.h"
  10 #include "base/strings/string_number_conversions.h"
  11 #include "base/values.h"
  12 #include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
  13 #include "net/base/escape.h"
  14 #include "net/http/http_request_headers.h"
  15 #include "net/http/http_status_code.h"
  16 #include "net/url_request/url_fetcher.h"
  17 #include "net/url_request/url_request_context_getter.h"
  18 #include "net/url_request/url_request_status.h"
  19 #include "url/gurl.h"
  20
  21 namespace gcm {
  22
  23 namespace {
  24
  25 const char kRegistrationRequestContentType[] =
  26     "application/x-www-form-urlencoded";
  27
  28 // Request constants.
  29 const char kAppIdKey[] = "app";
  30 const char kDeviceIdKey[] = "device";
  31 const char kLoginHeader[] = "AidLogin";
  32 const char kSenderKey[] = "sender";
  33
  34 // Request validation constants.
  35 const size_t kMaxSenders = 100;
  36
  37 // Response constants.
  38 const char kErrorPrefix[] = "Error=";
  39 const char kTokenPrefix[] = "token=";
  40 const char kDeviceRegistrationError[] = "PHONE_REGISTRATION_ERROR";
  41 const char kAuthenticationFailed[] = "AUTHENTICATION_FAILED";
  42 const char kInvalidSender[] = "INVALID_SENDER";
  43 const char kInvalidParameters[] = "INVALID_PARAMETERS";
  44
  45 void BuildFormEncoding(const std::string& key,
  46                        const std::string& value,
  47                        std::string* out) {
  48   if (!out->empty())
  49     out->append("&");
  50   out->append(key + "=" + net::EscapeUrlEncodedData(value, true));
  51 }
  52
  53 // Gets correct status from the error message.
  54 RegistrationRequest::Status GetStatusFromError(const std::string& error) {
  55   // TODO(fgorski): Improve error parsing in case there is nore then just an
  56   // Error=ERROR_STRING in response.
  57   if (error.find(kDeviceRegistrationError) != std::string::npos)
  58     return RegistrationRequest::DEVICE_REGISTRATION_ERROR;
  59   if (error.find(kAuthenticationFailed) != std::string::npos)
  60     return RegistrationRequest::AUTHENTICATION_FAILED;
  61   if (error.find(kInvalidSender) != std::string::npos)
  62     return RegistrationRequest::INVALID_SENDER;
  63   if (error.find(kInvalidParameters) != std::string::npos)
  64     return RegistrationRequest::INVALID_PARAMETERS;
  65   return RegistrationRequest::UNKNOWN_ERROR;
  66 }
  67
  68 // Indicates whether a retry attempt should be made based on the status of the
  69 // last request.
  70 bool ShouldRetryWithStatus(RegistrationRequest::Status status) {
  71   return status == RegistrationRequest::UNKNOWN_ERROR ||
  72          status == RegistrationRequest::AUTHENTICATION_FAILED ||
  73          status == RegistrationRequest::DEVICE_REGISTRATION_ERROR ||
  74          status == RegistrationRequest::HTTP_NOT_OK ||
  75          status == RegistrationRequest::URL_FETCHING_FAILED ||
  76          status == RegistrationRequest::RESPONSE_PARSING_FAILED;
  77 }
  78
  79 void RecordRegistrationStatusToUMA(RegistrationRequest::Status status) {
  80   UMA_HISTOGRAM_ENUMERATION("GCM.RegistrationRequestStatus", status,
  81                             RegistrationRequest::STATUS_COUNT);
  82 }
  83
  84 }  // namespace
  85
  86 RegistrationRequest::RequestInfo::RequestInfo(
  87     uint64 android_id,
  88     uint64 security_token,
  89     const std::string& app_id,
  90     const std::vector<std::string>& sender_ids)
  91     : android_id(android_id),
  92       security_token(security_token),
  93       app_id(app_id),
  94       sender_ids(sender_ids) {
  95 }
  96
  97 RegistrationRequest::RequestInfo::~RequestInfo() {}
  98
  99 RegistrationRequest::RegistrationRequest(
 100     const GURL& registration_url,
 101     const RequestInfo& request_info,
 102     const net::BackoffEntry::Policy& backoff_policy,
 103     const RegistrationCallback& callback,
 104     int max_retry_count,
 105     scoped_refptr<net::URLRequestContextGetter> request_context_getter,
 106     GCMStatsRecorder* recorder)
 107     : callback_(callback),
 108       request_info_(request_info),
 109       registration_url_(registration_url),
 110       backoff_entry_(&backoff_policy),
 111       request_context_getter_(request_context_getter),
 112       retries_left_(max_retry_count),
 113       recorder_(recorder),
 114       weak_ptr_factory_(this) {
 115   DCHECK_GE(max_retry_count, 0);
 116 }
 117
 118 RegistrationRequest::~RegistrationRequest() {}
 119
 120 void RegistrationRequest::Start() {
 121   DCHECK(!callback_.is_null());
 122   DCHECK(request_info_.android_id != 0UL);
 123   DCHECK(request_info_.security_token != 0UL);
 124   DCHECK(0 < request_info_.sender_ids.size() &&
 125          request_info_.sender_ids.size() <= kMaxSenders);
 126
 127   DCHECK(!url_fetcher_.get());
 128   url_fetcher_.reset(net::URLFetcher::Create(
 129       registration_url_, net::URLFetcher::POST, this));
 130   url_fetcher_->SetRequestContext(request_context_getter_);
 131
 132   std::string android_id = base::Uint64ToString(request_info_.android_id);
 133   std::string auth_header =
 134       std::string(net::HttpRequestHeaders::kAuthorization) + ": " +
 135       kLoginHeader + " " + android_id + ":" +
 136       base::Uint64ToString(request_info_.security_token);
 137   url_fetcher_->SetExtraRequestHeaders(auth_header);
 138
 139   std::string body;
 140   BuildFormEncoding(kAppIdKey, request_info_.app_id, &body);
 141   BuildFormEncoding(kDeviceIdKey, android_id, &body);
 142
 143   std::string senders;
 144   for (std::vector<std::string>::const_iterator iter =
 145            request_info_.sender_ids.begin();
 146        iter != request_info_.sender_ids.end();
 147        ++iter) {
 148     DCHECK(!iter->empty());
 149     if (!senders.empty())
 150       senders.append(",");
 151     senders.append(*iter);
 152   }
 153   BuildFormEncoding(kSenderKey, senders, &body);
 154   UMA_HISTOGRAM_COUNTS("GCM.RegistrationSenderIdCount",
 155                        request_info_.sender_ids.size());
 156
 157   DVLOG(1) << "Performing registration for: " << request_info_.app_id;
 158   DVLOG(1) << "Registration request: " << body;
 159   url_fetcher_->SetUploadData(kRegistrationRequestContentType, body);
 160   recorder_->RecordRegistrationSent(request_info_.app_id, senders);
 161   request_start_time_ = base::TimeTicks::Now();
 162   url_fetcher_->Start();
 163 }
 164
 165 void RegistrationRequest::RetryWithBackoff(bool update_backoff) {
 166   if (update_backoff) {
 167     DCHECK_GT(retries_left_, 0);
 168     --retries_left_;
 169     url_fetcher_.reset();
 170     backoff_entry_.InformOfRequest(false);
 171   }
 172
 173   if (backoff_entry_.ShouldRejectRequest()) {
 174     DVLOG(1) << "Delaying GCM registration of app: "
 175              << request_info_.app_id << ", for "
 176              << backoff_entry_.GetTimeUntilRelease().InMilliseconds()
 177              << " milliseconds.";
 178     base::MessageLoop::current()->PostDelayedTask(
 179         FROM_HERE,
 180         base::Bind(&RegistrationRequest::RetryWithBackoff,
 181                    weak_ptr_factory_.GetWeakPtr(),
 182                    false),
 183         backoff_entry_.GetTimeUntilRelease());
 184     return;
 185   }
 186
 187   Start();
 188 }
 189
 190 RegistrationRequest::Status RegistrationRequest::ParseResponse(
 191     const net::URLFetcher* source, std::string* token) {
 192   if (!source->GetStatus().is_success()) {
 193     LOG(ERROR) << "URL fetching failed.";
 194     return URL_FETCHING_FAILED;
 195   }
 196
 197   std::string response;
 198   if (!source->GetResponseAsString(&response)) {
 199     LOG(ERROR) << "Failed to parse registration response as a string.";
 200     return RESPONSE_PARSING_FAILED;
 201   }
 202
 203   if (source->GetResponseCode() == net::HTTP_OK) {
 204     size_t token_pos = response.find(kTokenPrefix);
 205     if (token_pos != std::string::npos) {
 206       *token = response.substr(token_pos + arraysize(kTokenPrefix) - 1);
 207       return SUCCESS;
 208     }
 209   }
 210
 211   // If we are able to parse a meaningful known error, let's do so. Some errors
 212   // will have HTTP_BAD_REQUEST, some will have HTTP_OK response code.
 213   size_t error_pos = response.find(kErrorPrefix);
 214   if (error_pos != std::string::npos) {
 215     std::string error = response.substr(
 216         error_pos + arraysize(kErrorPrefix) - 1);
 217     return GetStatusFromError(error);
 218   }
 219
 220   // If we cannot tell what the error is, but at least we know response code was
 221   // not OK.
 222   if (source->GetResponseCode() != net::HTTP_OK) {
 223     DLOG(ERROR) << "URL fetching HTTP response code is not OK. It is "
 224                 << source->GetResponseCode();
 225     return HTTP_NOT_OK;
 226   }
 227
 228   return UNKNOWN_ERROR;
 229 }
 230
 231 void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
 232   std::string token;
 233   Status status = ParseResponse(source, &token);
 234   RecordRegistrationStatusToUMA(status);
 235   recorder_->RecordRegistrationResponse(
 236       request_info_.app_id,
 237       request_info_.sender_ids,
 238       status);
 239
 240   if (ShouldRetryWithStatus(status)) {
 241     if (retries_left_ > 0) {
 242       recorder_->RecordRegistrationRetryRequested(
 243           request_info_.app_id,
 244           request_info_.sender_ids,
 245           retries_left_);
 246       RetryWithBackoff(true);
 247       return;
 248     }
 249
 250     status = REACHED_MAX_RETRIES;
 251     recorder_->RecordRegistrationResponse(
 252         request_info_.app_id,
 253         request_info_.sender_ids,
 254         status);
 255     RecordRegistrationStatusToUMA(status);
 256   }
 257
 258   if (status == SUCCESS) {
 259     UMA_HISTOGRAM_COUNTS("GCM.RegistrationRetryCount",
 260                          backoff_entry_.failure_count());
 261     UMA_HISTOGRAM_TIMES("GCM.RegistrationCompleteTime",
 262                         base::TimeTicks::Now() - request_start_time_);
 263   }
 264   callback_.Run(status, token);
 265 }
 266
 267 }  // namespace gcm