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

components/gcm_driver/gcm_stats_recorder_impl_unittest.cc

 // 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.
 
 #include "components/gcm_driver/gcm_stats_recorder_impl.h"
 
 #include <stdint.h>
 
 #include <deque>
 #include <string>
 #include <vector>
 
+#include "components/gcm_driver/crypto/gcm_encryption_provider.h"
 #include "google_apis/gcm/engine/mcs_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 
 namespace {
 
 static uint64_t kAndroidId = 4U;
 static const char kCheckinStatus[] = "URL_FETCHING_FAILED";
 static const char kHost[] = "www.example.com";
@@ skipping 68 matching lines @@
 static const char kDataDeletedMessageDetails[] =
     "Message has been deleted on server";
 
 static const char kDataSentToWireEvent[] = "Data msg sent to wire";
 static const char kSentToWireDetails[] = "Msg queued for 5 seconds";
 static const char kNotifySendStatusEvent[] = "SEND status: QUEUED";
 static const char kNotifySendStatusDetails[] = "Msg size: 99 bytes, TTL: 7";
 static const char kIncomingSendErrorEvent[] = "Received 'send error' msg";
 static const char kIncomingSendErrorDetails[] = "";
 
+static const GCMEncryptionProvider::DecryptionFailure kDecryptionFailureReason =
+    GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_PAYLOAD;
+
 }  // namespace
 
 class GCMStatsRecorderImplTest : public testing::Test {
  public:
   GCMStatsRecorderImplTest();
   ~GCMStatsRecorderImplTest() override;
   void SetUp() override;
 
   void VerifyRecordedCheckinCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.checkin_activities().size()));
   }
   void VerifyRecordedConnectionCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.connection_activities().size()));
   }
   void VerifyRecordedRegistrationCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.registration_activities().size()));
   }
   void VerifyRecordedReceivingCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.receiving_activities().size()));
   }
   void VerifyRecordedSendingCount(int expected_count) {
     EXPECT_EQ(expected_count,
               static_cast<int>(recorder_.sending_activities().size()));
   }
+  void VerifyRecordedDecryptionFailureCount(int expected_count) {
+    EXPECT_EQ(
+        expected_count,
+        static_cast<int>(recorder_.decryption_failure_activities().size()));
+  }
   void VerifyAllActivityQueueEmpty(const std::string& remark) {
     EXPECT_TRUE(recorder_.checkin_activities().empty()) << remark;
     EXPECT_TRUE(recorder_.connection_activities().empty()) << remark;
     EXPECT_TRUE(recorder_.registration_activities().empty()) << remark;
     EXPECT_TRUE(recorder_.receiving_activities().empty()) << remark;
     EXPECT_TRUE(recorder_.sending_activities().empty()) << remark;
+    EXPECT_TRUE(recorder_.decryption_failure_activities().empty()) << remark;
   }
 
   void VerifyCheckinInitiated(const std::string& remark) {
     VerifyCheckin(recorder_.checkin_activities(),
                   kCheckinInitiatedEvent,
                   kCheckinInitiatedDetails,
                   remark);
   }
 
   void VerifyCheckinDelayedDueToBackoff(const std::string& remark) {
@@ skipping 135 matching lines @@
                       remark);
   }
 
   void VerifyIncomingSendError(const std::string& remark) {
     VerifySendingData(recorder_.sending_activities(),
                       kIncomingSendErrorEvent,
                       kIncomingSendErrorDetails,
                       remark);
   }
 
+  void VerifyRecordedDecryptionFailure(const std::string& remark) {
+    const auto& queue = recorder_.decryption_failure_activities();
+
+    EXPECT_EQ(kAppId, queue.front().app_id) << remark;
+    EXPECT_EQ(
+        GCMEncryptionProvider::ToDecryptionFailureDetailsString(
+            kDecryptionFailureReason),
+        queue.front().details) << remark;
+  }
+
  protected:
   void VerifyCheckin(
       const std::deque<CheckinActivity>& queue,
       const std::string& event,
       const std::string& details,
       const std::string& remark) {
     EXPECT_EQ(event, queue.front().event) << remark;
     EXPECT_EQ(details, queue.front().details) << remark;
   }
 
@@ skipping 219 matching lines @@
 
   recorder_.RecordIncomingSendError(kAppId, kReceiverId, kMessageId);
   VerifyRecordedSendingCount(3);
   VerifyIncomingSendError("3rd call");
 
   recorder_.RecordDataSentToWire(kAppId, kReceiverId, kMessageId, kQueuedSec);
   VerifyRecordedSendingCount(4);
   VerifyDataSentToWire("4th call");
 }
 
+TEST_F(GCMStatsRecorderImplTest, RecordDecryptionFailureTest) {
+  recorder_.RecordDecryptionFailure(kAppId, kDecryptionFailureReason);
+  VerifyRecordedDecryptionFailureCount(1);
+
+  VerifyRecordedDecryptionFailure("1st call");
+}
+
 }  // namespace gcm