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

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 <deque>
+
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
+#include "base/strings/stringprintf.h"
 #include "base/time/default_clock.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/engine/connection_factory_impl.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "google_apis/gcm/engine/mcs_client.h"
 #include "google_apis/gcm/engine/registration_request.h"
 #include "google_apis/gcm/engine/unregistration_request.h"
+#include "google_apis/gcm/gcm_stats_recorder.h"
 #include "google_apis/gcm/protocol/mcs.pb.h"
 #include "net/http/http_network_session.h"
 #include "net/url_request/url_request_context.h"
 #include "url/gurl.h"
 
 namespace gcm {
 
 namespace {
 
 // Backoff policy. Shared across reconnection logic and checkin/(un)registration
@@ skipping 156 matching lines @@
     DCHECK(network_session_params);
     network_session_ = new net::HttpNetworkSession(*network_session_params);
     connection_factory_.reset(new ConnectionFactoryImpl(
         GURL(kMCSEndpoint),
         kDefaultBackoffPolicy,
         network_session_,
         net_log_.net_log()));
     mcs_client_.reset(new MCSClient(chrome_build_proto_.chrome_version(),
                                     clock_.get(),
                                     connection_factory_.get(),
-                                    gcm_store_.get()));
+                                    gcm_store_.get(),
+                                    &recorder_));
   }
 
   mcs_client_->Initialize(
       base::Bind(&GCMClientImpl::OnMCSError, weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&GCMClientImpl::OnMessageReceivedFromMCS,
                  weak_ptr_factory_.GetWeakPtr()),
       base::Bind(&GCMClientImpl::OnMessageSentToMCS,
                  weak_ptr_factory_.GetWeakPtr()),
       result.Pass());
 }
@@ skipping 33 matching lines @@
 
 void GCMClientImpl::StartCheckin(const CheckinInfo& checkin_info) {
   checkin_request_.reset(
       new CheckinRequest(base::Bind(&GCMClientImpl::OnCheckinCompleted,
                                     weak_ptr_factory_.GetWeakPtr()),
                          kDefaultBackoffPolicy,
                          chrome_build_proto_,
                          checkin_info.android_id,
                          checkin_info.secret,
                          account_ids_,
-                         url_request_context_getter_));
+                         url_request_context_getter_,
+                         &recorder_));
+  recorder_.RecordCheckin(checkin_info.android_id, GCMStatsRecorder::Initiated);
   checkin_request_->Start();
 }
 
 void GCMClientImpl::OnCheckinCompleted(uint64 android_id,
                                        uint64 security_token) {
   checkin_request_.reset();
 
   CheckinInfo checkin_info;
   checkin_info.android_id = android_id;
   checkin_info.secret = security_token;
@@ skipping 47 matching lines @@
       sender_ids);
   DCHECK_EQ(0u, pending_registrations_.count(app_id));
 
   RegistrationRequest* registration_request =
       new RegistrationRequest(request_info,
                               kDefaultBackoffPolicy,
                               base::Bind(&GCMClientImpl::OnRegisterCompleted,
                                          weak_ptr_factory_.GetWeakPtr(),
                                          app_id),
                               kMaxRegistrationRetries,
-                              url_request_context_getter_);
+                              url_request_context_getter_,
+                              &recorder_);
   pending_registrations_[app_id] = registration_request;
+  recorder_.RecordRegister(app_id, GCMStatsRecorder::Initiated, sender_ids);
   registration_request->Start();
 }
 
 void GCMClientImpl::OnRegisterCompleted(const std::string& app_id,
                                         RegistrationRequest::Status status,
                                         const std::string& registration_id) {
   DCHECK(delegate_);
 
   Result result;
   PendingRegistrations::iterator iter = pending_registrations_.find(app_id);
@@ skipping 73 matching lines @@
   for (MessageData::const_iterator iter = message.data.begin();
        iter != message.data.end();
        ++iter) {
     mcs_proto::AppData* app_data = stanza.add_app_data();
     app_data->set_key(iter->first);
     app_data->set_value(iter->second);
   }
 
   MCSMessage mcs_message(stanza);
   DVLOG(1) << "MCS message size: " << mcs_message.size();
+  recorder_.RecordSend(app_id, GCMStatsRecorder::Initiated, receiver_id,
+                       message.id, mcs_message.size());
   mcs_client_->SendMessage(mcs_message);
 }
 
 std::string GCMClientImpl::GetStateString() const {
   switch(state_) {
     case GCMClientImpl::INITIALIZED:
       return "INITIALIZED";
     case GCMClientImpl::UNINITIALIZED:
       return "UNINITIALIZED";
     case GCMClientImpl::LOADING:
       return "LOADING";
     case GCMClientImpl::INITIAL_DEVICE_CHECKIN:
       return "INITIAL_DEVICE_CHECKIN";
     case GCMClientImpl::READY:
       return "READY";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
+void GCMClientImpl::SetRecording(bool recording) {
+  recorder_.SetRecording(recording);
+}
+
+void GCMClientImpl::ClearActivityLogs() {
+  recorder_.Clear();
+}
+
 GCMClient::GCMStatistics GCMClientImpl::GetStatistics() const {
   GCMClient::GCMStatistics stats;
+  stats.is_recording = recorder_.IsRecording();
   stats.gcm_client_state = GCMClientImpl::GetStateString();
   stats.connection_client_created = mcs_client_.get() != NULL;
   if (mcs_client_.get()) {
     stats.connection_state = mcs_client_->GetStateString();
-    // TODO(juyik): add more statistics such as message metadata list, etc.
+    stats.send_queue_size = mcs_client_->GetSendQueueSize();
+    stats.unacked_queue_size = mcs_client_->GetUnackedQueueSize();
   }
   if (device_checkin_info_.android_id > 0)
     stats.android_id = device_checkin_info_.android_id;
+
+  for (std::deque<GCMStatsRecorder::CheckinActivity>::const_iterator it
+         = recorder_.CheckinActivities().begin();

[jianli, 2014/03/18 23:53:23]

nit: '=' should be moved to the end of previous line and there should be 4
spaces from '(' char of the previous line.

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

Done.

+       it != recorder_.CheckinActivities().end();
+       ++it) {
+    stats.checkins.push_back(*it);
+  }
+  for (std::deque<GCMStatsRecorder::RegisterActivity>::const_iterator it
+         = recorder_.RegisterActivities().begin();
+       it != recorder_.RegisterActivities().end();
+       ++it) {
+    stats.registers.push_back(*it);
+  }
+  for (std::deque<GCMStatsRecorder::SendMessageActivity>::const_iterator it
+         = recorder_.SendMessageActivities().begin();
+       it != recorder_.SendMessageActivities().end();
+       ++it) {
+    stats.sent_messages.push_back(*it);
+  }
+  for (std::deque<GCMStatsRecorder::ReceiveMessageActivity>::const_iterator it
+         = recorder_.ReceiveMessageActivities().begin();
+       it != recorder_.ReceiveMessageActivities().end();
+       ++it) {
+    stats.received_messages.push_back(*it);
+  }
   return stats;
 }
 
 void GCMClientImpl::OnMessageReceivedFromMCS(const gcm::MCSMessage& message) {
   switch (message.tag()) {
     case kLoginResponseTag:
       DVLOG(1) << "Login response received by GCM Client. Ignoring.";
       return;
     case kDataMessageStanzaTag:
       DVLOG(1) << "A downstream message received. Processing...";
@@ skipping 58 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_.RecordReceiveWithDetails(
+          GCMStatsRecorder::Success,
+          data_message_stanza.from(),
+          data_message_stanza.category(),
+          "Received DELETED MESSAGE");
       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() << ".";
+      recorder_.RecordReceiveWithDetails(
+          GCMStatsRecorder::Success,
+          data_message_stanza.from(),
+          data_message_stanza.category(),
+          "Unknown message type received");
       break;
   }
 }
 
 void GCMClientImpl::HandleIncomingDataMessage(
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   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;
+  recorder_.RecordReceiveDataMessage(incoming_message.sender_id,
+                                     data_message_stanza.category(),
+                                     incoming_message.data.size());
   delegate_->OnMessageReceived(data_message_stanza.category(),
                                incoming_message);
 }
 
 void GCMClientImpl::HandleIncomingSendError(
     const mcs_proto::DataMessageStanza& data_message_stanza,
     MessageData& message_data) {
   SendErrorDetails send_error_details;
   send_error_details.additional_data = message_data;
   send_error_details.result = SERVER_ERROR;
 
   MessageData::iterator iter =
       send_error_details.additional_data.find(kSendErrorMessageIdKey);
   if (iter != send_error_details.additional_data.end()) {
     send_error_details.message_id = iter->second;
     send_error_details.additional_data.erase(iter);
   }
 
+  recorder_.RecordReceiveWithDetails(
+      GCMStatsRecorder::Error,
+      std::string(),
+      data_message_stanza.category(),
+      base::StringPrintf("Send nessage server error. Message id: %s",
+                         send_error_details.message_id.c_str()));
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 void GCMClientImpl::SetMCSClientForTesting(scoped_ptr<MCSClient> mcs_client) {
   mcs_client_ = mcs_client.Pass();
 }
 
 }  // namespace gcm