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 "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/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 90 matching lines @@
 GCMInternalsBuilder::~GCMInternalsBuilder() {}
 
 scoped_ptr<base::Clock> GCMInternalsBuilder::BuildClock() {
   return make_scoped_ptr<base::Clock>(new base::DefaultClock());
 }
 
 scoped_ptr<MCSClient> GCMInternalsBuilder::BuildMCSClient(
     const std::string& version,
     base::Clock* clock,
     ConnectionFactory* connection_factory,
-    GCMStore* gcm_store) {
+    GCMStore* gcm_store,
+    GCMStatsRecorder* recorder) {
   return make_scoped_ptr<MCSClient>(
       new MCSClient(version,
                     clock,
                     connection_factory,
-                    gcm_store));
+                    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) {
   return make_scoped_ptr<ConnectionFactory>(
       new ConnectionFactoryImpl(endpoints,
                                 backoff_policy,
@@ skipping 83 matching lines @@
   endpoints.push_back(GURL(kMCSEndpointFallback));
   connection_factory_ = internals_builder_->BuildConnectionFactory(
       endpoints,
       kDefaultBackoffPolicy,
       network_session_,
       net_log_.net_log());
   mcs_client_ = internals_builder_->BuildMCSClient(
       chrome_build_proto_.chrome_version(),
       clock_.get(),
       connection_factory_.get(),
-      gcm_store_.get()).Pass();
+      gcm_store_.get(),
+      &recorder_).Pass();
 
   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 243 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_.RecordSendCalled(

[jianli, 2014/03/26 20:17:18]

"SendCalled" in the method name sounds a bit strange. Since we're going to call
MCSClient::SendMessage, can we move the recording logic to this method? Also,
probably better name like RecordMessageQueued?

[juyik, 2014/03/26 20:57:32]

OK, in that case this recording seems pretty redundant so I'll just remove it,
because in MCSClient::SendMessage I have already recorded a whole bunch of
status including queued.

+      app_id,
+      receiver_id,
+      message.id,
+      stanza.ByteSize(),
+      message.time_to_live);
   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.gcm_client_state = GCMClientImpl::GetStateString();
+  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();
-    // 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::SendingActivity>::const_iterator it =
+          recorder_.sending_activities().begin();
+       it != recorder_.sending_activities().end();
+       ++it) {
+    stats.sending.push_back(*it);
+  }
+  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()) {
     case kLoginResponseTag:
       DVLOG(1) << "Login response received by GCM Client. Ignoring.";
       return;
     case kDataMessageStanzaTag:
       DVLOG(1) << "A downstream message received. Processing...";
@@ skipping 108 matching lines @@
   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_.RecordIncomingSendError(
+      data_message_stanza.category(),
+      data_message_stanza.to(),
+      data_message_stanza.id(),
+      data_message_stanza.ByteSize(),
+      data_message_stanza.ttl());
   delegate_->OnMessageSendError(data_message_stanza.category(),
                                 send_error_details);
 }
 
 }  // namespace gcm