Add activity recording capability to gcm internals page. User can refresh, start/stop recording, an…

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 <string>
+
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "net/base/escape.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 27 matching lines @@
 const char kInvalidParameters[] = "INVALID_PARAMETERS";
 
 void BuildFormEncoding(const std::string& key,
                        const std::string& value,
                        std::string* out) {
   if (!out->empty())
     out->append("&");
   out->append(key + "=" + net::EscapeUrlEncodedData(value, true));
 }
 
+// Helper for getting string representation of the Status enum.
+std::string GetStatusString(RegistrationRequest::Status status) {

[fgorski, 2014/03/18 21:28:37]

Same here, I think it is better to pass the RegistrationRequest::Status to the
Stats recorder...

Also perhaps UMA loggin could be moved to the GCMStatsRecorder, per our
conversation (probably other patch).

[juyik, 2014/03/20 01:09:53]

Removed changes for now. Will do this in a future patch.

+  switch (status) {
+    case RegistrationRequest::SUCCESS:
+      return "SUCCESS";
+    case RegistrationRequest::INVALID_PARAMETERS:
+      return "INVALID_PARAMETERS";
+    case RegistrationRequest::INVALID_SENDER:
+      return "INVALID_SENDER";
+    case RegistrationRequest::AUTHENTICATION_FAILED:
+      return "AUTHENTICATION_FAILED";
+    case RegistrationRequest::DEVICE_REGISTRATION_ERROR:
+      return "DEVICE_REGISTRATION_ERROR";
+    case RegistrationRequest::UNKNOWN_ERROR:
+      return "UNKNOWN_ERROR";
+    case RegistrationRequest::URL_FETCHING_FAILED:
+      return "URL_FETCHING_FAILED";
+    case RegistrationRequest::HTTP_NOT_OK:
+      return "HTTP_NOT_OK";
+    case RegistrationRequest::RESPONSE_PARSING_FAILED:
+      return "RESPONSE_PARSING_FAILED";
+    case RegistrationRequest::REACHED_MAX_RETRIES:
+      return "REACHED_MAX_RETRIES";
+    default:
+      NOTREACHED();
+      return "UNKNOWN";
+  }
+}
+
 // Gets correct status from the error message.
 RegistrationRequest::Status GetStatusFromError(const std::string& error) {
   // TODO(fgorski): Improve error parsing in case there is nore then just an
   // Error=ERROR_STRING in response.
   if (error.find(kDeviceRegistrationError) != std::string::npos)
     return RegistrationRequest::DEVICE_REGISTRATION_ERROR;
   if (error.find(kAuthenticationFailed) != std::string::npos)
     return RegistrationRequest::AUTHENTICATION_FAILED;
   if (error.find(kInvalidSender) != std::string::npos)
     return RegistrationRequest::INVALID_SENDER;
@@ skipping 31 matching lines @@
       sender_ids(sender_ids) {
 }
 
 RegistrationRequest::RequestInfo::~RequestInfo() {}
 
 RegistrationRequest::RegistrationRequest(
     const RequestInfo& request_info,
     const net::BackoffEntry::Policy& backoff_policy,
     const RegistrationCallback& callback,
     int max_retry_count,
-    scoped_refptr<net::URLRequestContextGetter> request_context_getter)
+    scoped_refptr<net::URLRequestContextGetter> request_context_getter,
+    GCMStatsRecorder* recorder)
     : callback_(callback),
       request_info_(request_info),
       backoff_entry_(&backoff_policy),
       request_context_getter_(request_context_getter),
       retries_left_(max_retry_count),
+      recorder_(recorder),
       weak_ptr_factory_(this) {
   DCHECK_GE(max_retry_count, 0);
 }
 
 RegistrationRequest::~RegistrationRequest() {}
 
 void RegistrationRequest::Start() {
   DCHECK(!callback_.is_null());
   DCHECK(request_info_.android_id != 0UL);
   DCHECK(request_info_.security_token != 0UL);
@@ skipping 49 matching lines @@
              << " milliseconds.";
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RegistrationRequest::RetryWithBackoff,
                    weak_ptr_factory_.GetWeakPtr(),
                    false),
         backoff_entry_.GetTimeUntilRelease());
     return;
   }
 
+  recorder_->RecordRegister(request_info_.app_id, GCMStatsRecorder::Retry,
+                            request_info_.sender_ids);
   Start();
 }
 
 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;
   }
 
@@ skipping 31 matching lines @@
   return UNKNOWN_ERROR;
 }
 
 void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
   std::string token;
   Status status = ParseResponse(source, &token);
   RecordRegistrationStatusToUMA(status);
 
   if (ShouldRetryWithStatus(status)) {
     if (retries_left_ > 0) {
+      recorder_->RecordRegisterWithStatus(request_info_.app_id,
+                                          GCMStatsRecorder::RetryRequested,
+                                          request_info_.sender_ids,
+                                          GetStatusString(status));
       RetryWithBackoff(true);
       return;
     }
 
     status = REACHED_MAX_RETRIES;
     RecordRegistrationStatusToUMA(status);
+    recorder_->RecordRegisterWithStatus(request_info_.app_id,
+                                        GCMStatsRecorder::Failure,
+                                        request_info_.sender_ids,
+                                        GetStatusString(status));
+  } else {
+    recorder_->RecordRegister(request_info_.app_id,
+                              GCMStatsRecorder::Success,
+                              request_info_.sender_ids);
+
   }
 
   callback_.Run(status, token);
 }
 
 }  // namespace gcm