Record connection, registration, and receiving activities.

google_apis/gcm/gcm_client_impl.cc

 // Copyright 2013 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/gcm_client_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 128 matching lines @@
                     clock,
                     connection_factory,
                     gcm_store,
                     recorder));
 }
 
 scoped_ptr<ConnectionFactory> GCMInternalsBuilder::BuildConnectionFactory(
       const std::vector<GURL>& endpoints,
       const net::BackoffEntry::Policy& backoff_policy,
       scoped_refptr<net::HttpNetworkSession> network_session,
-      net::NetLog* net_log) {
+      net::NetLog* net_log,
+      GCMStatsRecorder* recorder) {
   return make_scoped_ptr<ConnectionFactory>(
       new ConnectionFactoryImpl(endpoints,
                                 backoff_policy,
                                 network_session,
-                                net_log));
+                                net_log,
+                                recorder));
 }
 
 GCMClientImpl::GCMClientImpl(scoped_ptr<GCMInternalsBuilder> internals_builder)
     : internals_builder_(internals_builder.Pass()),
       state_(UNINITIALIZED),
       clock_(internals_builder_->BuildClock()),
       url_request_context_getter_(NULL),
       pending_registration_requests_deleter_(&pending_registration_requests_),
       pending_unregistration_requests_deleter_(
           &pending_unregistration_requests_),
@@ skipping 68 matching lines @@
 
 void GCMClientImpl::InitializeMCSClient(
     scoped_ptr<GCMStore::LoadResult> result) {
   std::vector<GURL> endpoints;
   endpoints.push_back(GURL(kMCSEndpointMain));
   endpoints.push_back(GURL(kMCSEndpointFallback));
   connection_factory_ = internals_builder_->BuildConnectionFactory(
       endpoints,
       kDefaultBackoffPolicy,
       network_session_,
-      net_log_.net_log());
+      net_log_.net_log(),
+      &recorder_);
   mcs_client_ = internals_builder_->BuildMCSClient(
       chrome_build_proto_.chrome_version(),
       clock_.get(),
       connection_factory_.get(),
       gcm_store_.get(),
       &recorder_).Pass();
 
   mcs_client_->Initialize(
       base::Bind(&GCMClientImpl::OnMCSError, weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&GCMClientImpl::OnMessageReceivedFromMCS,
@@ skipping 156 matching lines @@
   DCHECK_EQ(0u, pending_registration_requests_.count(app_id));
 
   RegistrationRequest* registration_request =
       new RegistrationRequest(request_info,
                               kDefaultBackoffPolicy,
                               base::Bind(&GCMClientImpl::OnRegisterCompleted,
                                          weak_ptr_factory_.GetWeakPtr(),
                                          app_id,
                                          sender_ids),
                               kMaxRegistrationRetries,
-                              url_request_context_getter_);
+                              url_request_context_getter_,
+                              &recorder_);
   pending_registration_requests_[app_id] = registration_request;
   registration_request->Start();
 }
 
 void GCMClientImpl::OnRegisterCompleted(
     const std::string& app_id,
     const std::vector<std::string>& sender_ids,
     RegistrationRequest::Status status,
     const std::string& registration_id) {
   DCHECK(delegate_);
@@ skipping 51 matching lines @@
       device_checkin_info_.secret,
       app_id);
 
   UnregistrationRequest* unregistration_request =
       new UnregistrationRequest(
           request_info,
           kDefaultBackoffPolicy,
           base::Bind(&GCMClientImpl::OnUnregisterCompleted,
                      weak_ptr_factory_.GetWeakPtr(),
                      app_id),
-          url_request_context_getter_);
+          url_request_context_getter_,
+          &recorder_);
   pending_unregistration_requests_[app_id] = unregistration_request;
   unregistration_request->Start();
 }
 
 void GCMClientImpl::OnUnregisterCompleted(
     const std::string& app_id,
     UnregistrationRequest::Status status) {
   DVLOG(1) << "Unregister completed for app: " << app_id
            << " with " << (status ? "success." : "failure.");
   delegate_->OnUnregisterFinished(
@@ skipping 73 matching lines @@
   stats.is_recording = recorder_.is_recording();
   stats.gcm_client_state = GetStateString();
   stats.connection_client_created = mcs_client_.get() != NULL;
   if (mcs_client_.get()) {
     stats.connection_state = mcs_client_->GetStateString();
     stats.send_queue_size = mcs_client_->GetSendQueueSize();
     stats.resend_queue_size = mcs_client_->GetResendQueueSize();
   }
   if (device_checkin_info_.android_id > 0)
     stats.android_id = device_checkin_info_.android_id;
-  recorder_.CollectSendingActivities(&stats.sending_activities);
+  recorder_.CollectActivities(&stats.recorded_activities);
 
   for (RegistrationInfoMap::const_iterator it = registrations_.begin();
        it != registrations_.end(); ++it) {
     stats.registered_app_ids.push_back(it->first);
   }
   return stats;
 }
 
 void GCMClientImpl::OnMessageReceivedFromMCS(const gcm::MCSMessage& message) {
   switch (message.tag()) {
@@ skipping 63 matching lines @@
   if (iter != message_data.end()) {
     message_type = DecodeMessageType(iter->second);
     message_data.erase(iter);
   }
 
   switch (message_type) {
     case DATA_MESSAGE:
       HandleIncomingDataMessage(data_message_stanza, message_data);
       break;
     case DELETED_MESSAGES:
+      recorder_.RecordDataMessageRecieved(data_message_stanza.category(),
+                                          data_message_stanza.from(),
+                                          data_message_stanza.ByteSize(),
+                                          true,
+                                          GCMStatsRecorder::DELETED_MESSAGES);
       delegate_->OnMessagesDeleted(data_message_stanza.category());
       break;
     case SEND_ERROR:
       HandleIncomingSendError(data_message_stanza, message_data);
       break;
     case UNKNOWN:
     default:  // Treat default the same as UNKNOWN.
       DVLOG(1) << "Unknown message_type received. Message ignored. "
                << "App ID: " << data_message_stanza.category() << ".";
       break;
   }
 }
 
 void GCMClientImpl::HandleIncomingDataMessage(
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   std::string app_id = data_message_stanza.category();
 
   // Drop the message when the app is not registered for the sender of the
   // message.
   RegistrationInfoMap::iterator iter = registrations_.find(app_id);
-  if (iter == registrations_.end() ||
+  bool not_registered =
+      iter == registrations_.end() ||
       std::find(iter->second->sender_ids.begin(),
                 iter->second->sender_ids.end(),
-                data_message_stanza.from()) == iter->second->sender_ids.end()) {
+                data_message_stanza.from()) == iter->second->sender_ids.end();
+  recorder_.RecordDataMessageRecieved(app_id, data_message_stanza.from(),
+      data_message_stanza.ByteSize(), !not_registered,
+      GCMStatsRecorder::DATA_MESSAGE);
+  if (not_registered) {
     return;
   }
 
   IncomingMessage incoming_message;
   incoming_message.sender_id = data_message_stanza.from();
   if (data_message_stanza.has_token())
     incoming_message.collapse_key = data_message_stanza.token();
   incoming_message.data = message_data;
   delegate_->OnMessageReceived(app_id, incoming_message);
 }
@@ skipping 14 matching lines @@
 
   recorder_.RecordIncomingSendError(
       data_message_stanza.category(),
       data_message_stanza.to(),
       data_message_stanza.id());
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 }  // namespace gcm