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

google_apis/gcm/engine/checkin_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/checkin_request.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "google_apis/gcm/protocol/checkin.pb.h"
@@ skipping 35 matching lines @@
 
 }  // namespace
 
 CheckinRequest::CheckinRequest(
     const CheckinRequestCallback& callback,
     const net::BackoffEntry::Policy& backoff_policy,
     const checkin_proto::ChromeBuildProto& chrome_build_proto,
     uint64 android_id,
     uint64 security_token,
     const std::vector<std::string>& account_ids,
-    net::URLRequestContextGetter* request_context_getter)
+    net::URLRequestContextGetter* request_context_getter,
+    GCMStatsRecorder* recorder)
     : request_context_getter_(request_context_getter),
       callback_(callback),
       backoff_entry_(&backoff_policy),
       chrome_build_proto_(chrome_build_proto),
       android_id_(android_id),
       security_token_(security_token),
       account_ids_(account_ids),
+      recorder_(recorder),
       weak_ptr_factory_(this) {
 }
 
 CheckinRequest::~CheckinRequest() {}
 
 void CheckinRequest::Start() {
   DCHECK(!url_fetcher_.get());
 
   checkin_proto::AndroidCheckinRequest request;
   request.set_id(android_id_);
@@ skipping 37 matching lines @@
              << " milliseconds.";
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&CheckinRequest::RetryWithBackoff,
                    weak_ptr_factory_.GetWeakPtr(),
                    false),
         backoff_entry_.GetTimeUntilRelease());
     return;
   }
 
+  recorder_->RecordCheckin(android_id_, GCMStatsRecorder::Retry);
   Start();
 }
 
 void CheckinRequest::OnURLFetchComplete(const net::URLFetcher* source) {
   std::string response_string;
   checkin_proto::AndroidCheckinResponse response_proto;
   if (!source->GetStatus().is_success()) {
     LOG(ERROR) << "Failed to get checkin response. Fetcher failed. Retrying.";
     RecordCheckinStatusToUMA(URL_FETCHING_FAILED);
     RetryWithBackoff(true);
     return;
   }
 
   net::HttpStatusCode response_status = static_cast<net::HttpStatusCode>(
       source->GetResponseCode());
   if (response_status == net::HTTP_BAD_REQUEST ||
       response_status == net::HTTP_UNAUTHORIZED) {
     // BAD_REQUEST indicates that the request was malformed.
     // UNAUTHORIZED indicates that security token didn't match the android id.
     LOG(ERROR) << "No point retrying the checkin with status: "
                << response_status << ". Checkin failed.";
     RecordCheckinStatusToUMA(response_status == net::HTTP_BAD_REQUEST ?
         HTTP_BAD_REQUEST : HTTP_UNAUTHORIZED);
+    recorder_->RecordCheckin(android_id_, GCMStatsRecorder::Failure);
     callback_.Run(0,0);
     return;
   }
 
   if (response_status != net::HTTP_OK ||
       !source->GetResponseAsString(&response_string) ||
       !response_proto.ParseFromString(response_string)) {
     LOG(ERROR) << "Failed to get checkin response. HTTP Status: "
                << response_status << ". Retrying.";
     RecordCheckinStatusToUMA(response_status != net::HTTP_OK ?
@@ skipping 10 matching lines @@
     RecordCheckinStatusToUMA(ZERO_ID_OR_TOKEN);
     RetryWithBackoff(true);
     return;
   }
 
   RecordCheckinStatusToUMA(SUCCESS);
   callback_.Run(response_proto.android_id(), response_proto.security_token());
 }
 
 }  // namespace gcm