Record connection, registration, and receiving activities.

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"
 #include "base/values.h"
+#include "google_apis/gcm/monitoring/gcm_stats_recorder.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"
 #include "net/url_request/url_request_status.h"
 #include "url/gurl.h"
 
 namespace gcm {
 
@@ skipping 73 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 24 matching lines @@
     DCHECK(!iter->empty());
     if (!senders.empty())
       senders.append(",");
     senders.append(*iter);
   }
   BuildFormEncoding(kSenderKey, senders, &body);
 
   DVLOG(1) << "Performing registration for: " << request_info_.app_id;
   DVLOG(1) << "Registration request: " << body;
   url_fetcher_->SetUploadData(kRegistrationRequestContentType, body);
+  recorder_->RecordRegistrationSent(android_id, request_info_.app_id, senders);
   url_fetcher_->Start();
 }
 
 void RegistrationRequest::RetryWithBackoff(bool update_backoff) {
   if (update_backoff) {
     DCHECK_GT(retries_left_, 0);
     --retries_left_;
     url_fetcher_.reset();
     backoff_entry_.InformOfRequest(false);
   }
@@ skipping 53 matching lines @@
     return HTTP_NOT_OK;
   }
 
   return UNKNOWN_ERROR;
 }
 
 void RegistrationRequest::OnURLFetchComplete(const net::URLFetcher* source) {
   std::string token;
   Status status = ParseResponse(source, &token);
   RecordRegistrationStatusToUMA(status);
+  recorder_->RecordRegistrationResponse(
+      base::Uint64ToString(request_info_.android_id),
+      request_info_.app_id,
+      request_info_.sender_ids,
+      status);
 
   if (ShouldRetryWithStatus(status)) {
     if (retries_left_ > 0) {
+      recorder_->RecordRegistrationRetryRequested(
+          base::Uint64ToString(request_info_.android_id),
+          request_info_.app_id,
+          request_info_.sender_ids,
+          retries_left_);
       RetryWithBackoff(true);
       return;
     }
 
     status = REACHED_MAX_RETRIES;
+    recorder_->RecordRegistrationResponse(
+        base::Uint64ToString(request_info_.android_id),
+        request_info_.app_id,
+        request_info_.sender_ids,
+        status);
     RecordRegistrationStatusToUMA(status);
   }
 
   callback_.Run(status, token);
 }
 
 }  // namespace gcm