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

google_apis/gcm/engine/mcs_client.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/engine/mcs_client.h"
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/time/clock.h"
 #include "base/time/time.h"
 #include "google_apis/gcm/base/mcs_util.h"
 #include "google_apis/gcm/base/socket_stream.h"
 #include "google_apis/gcm/engine/connection_factory.h"
+#include "google_apis/gcm/monitoring/gcm_stats_recorder.h"
 
 using namespace google::protobuf::io;
 
 namespace gcm {
 
 namespace {
 
 typedef scoped_ptr<google::protobuf::MessageLite> MCSProto;
 
 // The category of messages intended for the GCM client itself from MCS.
@@ skipping 93 matching lines @@
 
   // The protobuf of the message itself.
   MCSProto protobuf;
 };
 
 ReliablePacketInfo::ReliablePacketInfo()
   : stream_id(0), tag(0) {
 }
 ReliablePacketInfo::~ReliablePacketInfo() {}
 
+int MCSClient::GetSendQueueSize() const {
+  return to_send_.size();
+}
+
+int MCSClient::GetResendQueueSize() const {
+  return to_resend_.size();
+}
+
 std::string MCSClient::GetStateString() const {
   switch(state_) {
     case UNINITIALIZED:
       return "UNINITIALIZED";
     case LOADED:
       return "LOADED";
     case CONNECTING:
       return "CONNECTING";
     case CONNECTED:
       return "CONNECTED";
     default:
       NOTREACHED();
       return std::string();
   }
 }
 
 MCSClient::MCSClient(const std::string& version_string,
                      base::Clock* clock,
                      ConnectionFactory* connection_factory,
-                     GCMStore* gcm_store)
+                     GCMStore* gcm_store,
+                     GCMStatsRecorder* recorder)
     : version_string_(version_string),
       clock_(clock),
       state_(UNINITIALIZED),
       android_id_(0),
       security_token_(0),
       connection_factory_(connection_factory),
       connection_handler_(NULL),
       last_device_to_server_stream_id_received_(0),
       last_server_to_device_stream_id_received_(0),
       stream_id_out_(0),
       stream_id_in_(0),
       gcm_store_(gcm_store),
+      recorder_(recorder),
       weak_ptr_factory_(this) {
 }
 
 MCSClient::~MCSClient() {
 }
 
 void MCSClient::Initialize(
     const ErrorCallback& error_callback,
     const OnMessageReceivedCallback& message_received_callback,
     const OnMessageSentCallback& message_sent_callback,
@@ skipping 315 matching lines @@
   if (packet_info->tag == kDataMessageStanzaTag) {
     mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(
             packet_info->protobuf.get());
     uint64 sent = data_message->sent();
     DCHECK_GT(sent, 0U);
     int queued = (clock_->Now().ToInternalValue() /
         base::Time::kMicrosecondsPerSecond) - sent;
     DVLOG(1) << "Message was queued for " << queued << " seconds.";
     data_message->set_queued(queued);
+    recorder_->RecordDataSentToWire(
+        data_message->category(),
+        data_message->to(),
+        data_message->id(),
+        queued);
   }
 
   // Set the proper last received stream id to acknowledge received server
   // packets.
   DVLOG(1) << "Setting last stream id received to "
            << stream_id_in_;
   SetLastStreamIdReceived(stream_id_in_,
                           packet_info->protobuf.get());
   if (stream_id_in_ != last_server_to_device_stream_id_received_) {
     last_server_to_device_stream_id_received_ = stream_id_in_;
@@ skipping 347 matching lines @@
 }
 
 void MCSClient::NotifyMessageSendStatus(
     const google::protobuf::MessageLite& protobuf,
     MessageSendStatus status) {
   if (GetMCSProtoTag(protobuf) != kDataMessageStanzaTag)
     return;
 
   const mcs_proto::DataMessageStanza* data_message_stanza =
       reinterpret_cast<const mcs_proto::DataMessageStanza*>(&protobuf);
+  recorder_->RecordNotifySendStatus(
+      data_message_stanza->category(),
+      data_message_stanza->to(),
+      data_message_stanza->id(),
+      status,
+      protobuf.ByteSize(),
+      data_message_stanza->ttl());
   message_sent_callback_.Run(
       data_message_stanza->device_user_id(),
       data_message_stanza->category(),
       data_message_stanza->id(),
       status);
 }
 
 MCSClient::MCSPacketInternal MCSClient::PopMessageForSend() {
   MCSPacketInternal packet = to_send_.front();
   to_send_.pop_front();
 
   if (packet->tag == kDataMessageStanzaTag) {
     mcs_proto::DataMessageStanza* data_message =
         reinterpret_cast<mcs_proto::DataMessageStanza*>(packet->protobuf.get());
     CollapseKey collapse_key(*data_message);
     if (collapse_key.IsValid())
       collapse_key_map_.erase(collapse_key);
   }
 
   return packet;
 }
 
 } // namespace gcm