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/strings/stringprintf.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"
 
 using namespace google::protobuf::io;
 
 namespace gcm {
 
@@ skipping 33 matching lines @@
     return false;
   std::vector<std::string> new_list;
   for (int i = 0; i < selective_ack.id_size(); ++i) {
     DCHECK(!selective_ack.id(i).empty());
     new_list.push_back(selective_ack.id(i));
   }
   id_list->swap(new_list);
   return true;
 }
 
+// Helper for getting string representation of the MessageSendStatus enum.
+std::string GetMessageSendStatusString(
+    gcm::MCSClient::MessageSendStatus status) {
+  switch (status) {
+    case gcm::MCSClient::QUEUED:
+      return "QUEUED";
+    case gcm::MCSClient::SENT:
+      return "SENT";
+    case gcm::MCSClient::QUEUE_SIZE_LIMIT_REACHED:
+      return "QUEUE_SIZE_LIMIT_REACHED";
+    case gcm::MCSClient::APP_QUEUE_SIZE_LIMIT_REACHED:
+      return "APP_QUEUE_SIZE_LIMIT_REACHED";
+    case gcm::MCSClient::MESSAGE_TOO_LARGE:
+      return "MESSAGE_TOO_LARGE";
+    case gcm::MCSClient::NO_CONNECTION_ON_ZERO_TTL:
+      return "NO_CONNECTION_ON_ZERO_TTL";
+    case gcm::MCSClient::TTL_EXCEEDED:
+      return "TTL_EXCEEDED";
+    default:
+      NOTREACHED();
+      return "UNKNOWN";
+  }
+}
+
 }  // namespace
 
 class CollapseKey {
  public:
   explicit CollapseKey(const mcs_proto::DataMessageStanza& message);
   ~CollapseKey();
 
   // Comparison operator for use in maps.
   bool operator<(const CollapseKey& right) const;
 
@@ skipping 45 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::GetUnackedQueueSize() 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_->RecordSending(
+        data_message->category(),
+        data_message->to(),
+        data_message->id(),
+        "Sent to wire",
+        base::StringPrintf("Msg queued for %d seconds", 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_->RecordSendingWithUMAEnum(
+      data_message_stanza->category(),
+      data_message_stanza->to(),
+      data_message_stanza->id(),
+      base::StringPrintf("SEND status: %s",
+                         GetMessageSendStatusString(status).c_str()),
+      base::StringPrintf("Msg size: %d bytes, TTL: %d", protobuf.ByteSize(),
+                         data_message_stanza->ttl()),
+      "GCM.SendMessageStatus",
+      status,
+      gcm::MCSClient::SEND_STATUS_COUNT);
   message_sent_callback_.Run(
       data_message_stanza->device_user_id(),
       data_message_stanza->category(),
       data_message_stanza->id(),
       status);
 }
 
 void MCSClient::SetGCMStoreForTesting(GCMStore* gcm_store) {
   gcm_store_ = gcm_store;
 }
 
 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