Add 3 more registartion status codes for UMA collection. Also added tests.

google_apis/gcm/engine/registration_request.cc

 // Copyright 2014 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/gcm/engine/registration_request.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 52 matching lines @@
   if (error == kInvalidParameters)
     return RegistrationRequest::INVALID_PARAMETERS;
   return RegistrationRequest::UNKNOWN_ERROR;
 }
 
 // Indicates whether a retry attempt should be made based on the status of the
 // last request.
 bool ShouldRetryWithStatus(RegistrationRequest::Status status) {
   return status == RegistrationRequest::UNKNOWN_ERROR ||
          status == RegistrationRequest::AUTHENTICATION_FAILED ||
-         status == RegistrationRequest::DEVICE_REGISTRATION_ERROR;
+         status == RegistrationRequest::DEVICE_REGISTRATION_ERROR ||
+         status == RegistrationRequest::HTTP_NOT_OK ||
+         status == RegistrationRequest::URL_FETCHING_FAILED ||
+         status == RegistrationRequest::RESPONSE_PARSING_FAILED;
 }
 
 void RecordRegistrationStatusToUMA(RegistrationRequest::Status status) {
   UMA_HISTOGRAM_ENUMERATION("GCM.RegistrationRequestStatus", status,
                             RegistrationRequest::STATUS_COUNT);
 }
 
 }  // namespace
 
 RegistrationRequest::RequestInfo::RequestInfo(
@@ skipping 84 matching lines @@
         base::Bind(&RegistrationRequest::RetryWithBackoff,
                    weak_ptr_factory_.GetWeakPtr(),
                    false),
         backoff_entry_.GetTimeUntilRelease());
     return;
   }
 
   Start();
 }
 
-void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
+RegistrationRequest::Status RegistrationRequest::ParseResponse(
+    const net::URLFetcher* source, std::string* token) {
+  if (!source->GetStatus().is_success()) {
+    LOG(ERROR) << "URL fetching failed.";
+    return URL_FETCHING_FAILED;
+  }
+  if (source->GetResponseCode() != net::HTTP_OK) {
+    LOG(ERROR) << "URL fetching HTTP response code is not OK. It is "
+               << source->GetResponseCode();
+    return HTTP_NOT_OK;
+  }
   std::string response;
-  if (!source->GetStatus().is_success() ||
-      source->GetResponseCode() != net::HTTP_OK ||
-      !source->GetResponseAsString(&response)) {
-    LOG(ERROR) << "Failed to get registration response: "
-               << source->GetStatus().is_success() << " "
-               << source->GetResponseCode();
-    RetryWithBackoff(true);
-    return;
+  if (!source->GetResponseAsString(&response)) {
+    LOG(ERROR) << "Failed to parse registration response as a string.";
+    return RESPONSE_PARSING_FAILED;
   }
 
   DVLOG(1) << "Parsing registration response: " << response;
   size_t token_pos = response.find(kTokenPrefix);
   if (token_pos != std::string::npos) {
-    std::string token =
-        response.substr(token_pos + arraysize(kTokenPrefix) - 1);
-    RecordRegistrationStatusToUMA(SUCCESS);
-    callback_.Run(SUCCESS, token);
-    return;
+    *token = response.substr(token_pos + arraysize(kTokenPrefix) - 1);
+    return SUCCESS;
   }
 
   size_t error_pos = response.find(kErrorPrefix);
-  Status status = UNKNOWN_ERROR;
-  if (error_pos != std::string::npos) {
-    std::string error =
-        response.substr(error_pos + arraysize(kErrorPrefix) - 1);
-    status = GetStatusFromError(error);
-  }
-  RecordRegistrationStatusToUMA(status);
+  if (error_pos == std::string::npos)
+    return UNKNOWN_ERROR;
+  std::string error = response.substr(error_pos + arraysize(kErrorPrefix) - 1);
+  return GetStatusFromError(error);
+}
 
-  if (ShouldRetryWithStatus(status)) {
+void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
+  std::string token;
+  Status status = ParseResponse(source, &token);
+  RecordRegistrationStatusToUMA(status );
+  if (ShouldRetryWithStatus(status))
     RetryWithBackoff(true);
-    return;
-  }
-
-  callback_.Run(status, std::string());
+  else
+    callback_.Run(status, token);
 }
 
 }  // namespace gcm