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

google_apis/gcm/engine/mcs_client.h

 // 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.
 
 #ifndef GOOGLE_APIS_GCM_ENGINE_MCS_CLIENT_H_
 #define GOOGLE_APIS_GCM_ENGINE_MCS_CLIENT_H_
 
 #include <deque>
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "google_apis/gcm/base/gcm_export.h"
 #include "google_apis/gcm/base/mcs_message.h"
 #include "google_apis/gcm/engine/connection_handler.h"
 #include "google_apis/gcm/engine/gcm_store.h"
 #include "google_apis/gcm/engine/heartbeat_manager.h"
+#include "google_apis/gcm/gcm_stats_recorder.h"
 
 namespace base {
 class Clock;
 }  // namespace base
 
 namespace google {
 namespace protobuf {
 class MessageLite;
 }  // namespace protobuf
 }  // namespace google
 
 namespace mcs_proto {
 class LoginRequest;
 }
 
 namespace gcm {
 
 class CollapseKey;
 class ConnectionFactory;
+class GCMStatsRecorder;
 struct ReliablePacketInfo;
 
 // An MCS client. This client is in charge of all communications with an
 // MCS endpoint, and is capable of reliably sending/receiving GCM messages.
 // NOTE: Not thread safe. This class should live on the same thread as that
 // network requests are performed on.
 class GCM_EXPORT MCSClient {
  public:
   // Any change made to this enum should have corresponding change in the
   // GetStateString(...) function.
   enum State {
     UNINITIALIZED,  // Uninitialized.
     LOADED,         // GCM Load finished, waiting to connect.
     CONNECTING,     // Connection in progress.
     CONNECTED,      // Connected and running.
   };
 
+  // Any change made to this enum should have corresponding change in the
+  // GetMessageSendStatusString(...) function in mcs_client.cc.
   enum MessageSendStatus {
     // Message was queued succcessfully.
     QUEUED,
     // Message was sent to the server and the ACK was received.
     SENT,
     // Message not saved, because total queue size limit reached.
     QUEUE_SIZE_LIMIT_REACHED,
-    // Messgae not saved, because app queue size limit reached.
+    // Message not saved, because app queue size limit reached.
     APP_QUEUE_SIZE_LIMIT_REACHED,
     // Message too large to send.
     MESSAGE_TOO_LARGE,
     // Message not send becuase of TTL = 0 and no working connection.
     NO_CONNECTION_ON_ZERO_TTL,
     // Message exceeded TTL.
-    TTL_EXCEEDED
+    TTL_EXCEEDED,
+
+    // NOTE: always keep this entry at the end. Add new status types only
+    // immediately above this line. Make sure to update the corresponding
+    // histogram enum accordingly.
+    SEND_STATUS_COUNT
   };
 
   // Callback for MCSClient's error conditions.
   // TODO(fgorski): Keeping it as a callback with intention to add meaningful
   // error information.
   typedef base::Callback<void()> ErrorCallback;
   // Callback when a message is received.
   typedef base::Callback<void(const MCSMessage& message)>
       OnMessageReceivedCallback;
   // Callback when a message is sent (and receipt has been acknowledged by
   // the MCS endpoint).
   typedef base::Callback<
       void(int64 user_serial_number,
            const std::string& app_id,
            const std::string& message_id,
            MessageSendStatus status)> OnMessageSentCallback;
 
   MCSClient(const std::string& version_string,
             base::Clock* clock,
             ConnectionFactory* connection_factory,
-            GCMStore* gcm_store);
+            GCMStore* gcm_store,
+            GCMStatsRecorder* recorder);
   virtual ~MCSClient();
 
   // Initialize the client. Will load any previous id/token information as well
   // as unacknowledged message information from the GCM storage, if it exists,
   // passing the id/token information back via |initialization_callback| along
   // with a |success == true| result. If no GCM information is present (and
   // this is therefore a fresh client), a clean GCM store will be created and
   // values of 0 will be returned via |initialization_callback| with
   // |success == true|.
   /// If an error loading the GCM store is encountered,
@@ skipping 17 matching lines @@
   // Whether to use RMQ depends on whether the protobuf has |ttl| set or not.
   // |ttl == 0| denotes the message should only be sent if the connection is
   // open. |ttl > 0| will keep the message saved for |ttl| seconds, after which
   // it will be dropped if it was unable to be sent. When a message is dropped,
   // |message_sent_callback_| is invoked with a TTL expiration error.
   virtual void SendMessage(const MCSMessage& message);
 
   // Returns the current state of the client.
   State state() const { return state_; }
 
+  // Returns the size of the send message queue.
+  int GetSendQueueSize() const;
+
+  // Returns the size of the un-acked messaage queue.
+  int GetUnackedQueueSize() const;
+
   // Returns text representation of the state enum.
   std::string GetStateString() const;
 
  protected:
   // Sets a |gcm_store| for testing. Does not take ownership.
   // TODO(fgorski): Remove this method. Create GCMEngineFactory that will create
   // components of the engine.
   void SetGCMStoreForTesting(GCMStore* gcm_store);
 
  private:
@@ skipping 118 matching lines @@
   // acknowledged. They do not have associated stream ids, and will be
   // acknowledged on the next login attempt.
   PersistentIdList restored_unackeds_server_ids_;
 
   // The GCM persistent store. Not owned.
   GCMStore* gcm_store_;
 
   // Manager to handle triggering/detecting heartbeats.
   HeartbeatManager heartbeat_manager_;
 
+  // Recorder that records GCM activities for debugging purpose. Not owned.
+  GCMStatsRecorder* recorder_;
+
   base::WeakPtrFactory<MCSClient> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MCSClient);
 };
 
 } // namespace gcm
 
 #endif  // GOOGLE_APIS_GCM_ENGINE_MCS_CLIENT_H_