List message decryption failures on chrome://gcm-internals

components/gcm_driver/gcm_stats_recorder_impl.h

 // Copyright 2014 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 COMPONENTS_GCM_DRIVER_GCM_STATS_RECORDER_IMPL_H_
 #define COMPONENTS_GCM_DRIVER_GCM_STATS_RECORDER_IMPL_H_
 
 #include <stdint.h>
 
 #include <deque>
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/time/time.h"
+#include "components/gcm_driver/crypto/gcm_encryption_provider.h"
 #include "components/gcm_driver/gcm_activity.h"
 #include "google_apis/gcm/engine/connection_factory.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/monitoring/gcm_stats_recorder.h"
 
 namespace gcm {
 
 // Records GCM internal stats and activities for debugging purpose. Recording
 // can be turned on/off by calling set_is_recording(...) function. It is turned
 // off by default.
 // This class is not thread safe. It is meant to be owned by a gcm client
 // instance.
 class GCMStatsRecorderImpl : public GCMStatsRecorder {
  public:
   GCMStatsRecorderImpl();
   ~GCMStatsRecorderImpl() override;
 
   // Set a delegate to receive callback from the recorder.
   void SetDelegate(Delegate* delegate);
 
   // Clear all recorded activities.
   void Clear();
 
+  // Records a message decryption failure caused by |reason| for |app_id|.
+  void RecordDecryptionFailure(const std::string& app_id,
+                               GCMEncryptionProvider::DecryptionFailure reason);
+
   // GCMStatsRecorder implementation:
   void RecordCheckinInitiated(uint64_t android_id) override;
   void RecordCheckinDelayedDueToBackoff(int64_t delay_msec) override;
   void RecordCheckinSuccess() override;
   void RecordCheckinFailure(const std::string& status,
                             bool will_retry) override;
   void RecordConnectionInitiated(const std::string& host) override;
   void RecordConnectionDelayedDueToBackoff(int64_t delay_msec) override;
   void RecordConnectionSuccess() override;
   void RecordConnectionFailure(int network_error) override;
@@ skipping 51 matching lines @@
   }
   const std::deque<RegistrationActivity>& registration_activities() const {
     return registration_activities_;
   }
   const std::deque<ReceivingActivity>& receiving_activities() const {
     return receiving_activities_;
   }
   const std::deque<SendingActivity>& sending_activities() const {
     return sending_activities_;
   }
+  const std::deque<DecryptionFailureActivity>& decryption_failure_activities()
+      const {
+    return decryption_failure_activities_;
+  }
 
  protected:
   // Notify the recorder delegate, if it exists, that an activity has been
   // recorded.
   void NotifyActivityRecorded();
 
   void RecordCheckin(const std::string& event,
                      const std::string& details);
 
   void RecordConnection(const std::string& event,
@@ skipping 17 matching lines @@
                      const std::string& details);
 
   bool is_recording_;
   Delegate* delegate_;
 
   std::deque<CheckinActivity> checkin_activities_;
   std::deque<ConnectionActivity> connection_activities_;
   std::deque<RegistrationActivity> registration_activities_;
   std::deque<ReceivingActivity> receiving_activities_;
   std::deque<SendingActivity> sending_activities_;
+  std::deque<DecryptionFailureActivity> decryption_failure_activities_;
 
   base::TimeTicks last_connection_initiation_time_;
   base::TimeTicks last_connection_success_time_;
   bool data_message_received_since_connected_;
   base::TimeTicks last_received_data_message_burst_start_time_;
   base::TimeTicks last_received_data_message_time_within_burst_;
   int64_t received_data_message_burst_size_;
 
   DISALLOW_COPY_AND_ASSIGN(GCMStatsRecorderImpl);
 };
 
 }  // namespace gcm
 
 #endif  // COMPONENTS_GCM_DRIVER_GCM_STATS_RECORDER_IMPL_H_