Add various UMA histograms for measuring GCM crypto performance

components/gcm_driver/crypto/gcm_encryption_provider_unittest.cc

 // Copyright 2015 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/crypto/gcm_encryption_provider.h"
 
 #include <stddef.h>
 
 #include <sstream>
 #include <string>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
+#include "base/test/histogram_tester.h"
 #include "components/gcm_driver/common/gcm_messages.h"
 #include "components/gcm_driver/crypto/gcm_key_store.h"
 #include "components/gcm_driver/crypto/gcm_message_cryptographer.h"
 #include "components/gcm_driver/crypto/p256_key_util.h"
 #include "crypto/random.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gcm {
 namespace {
 
@@ skipping 39 matching lines @@
   }
 
   // To be used as a callback for GCMKeyStore::CreateKeys().
   void DidCreateKeys(KeyPair* pair_out, std::string* auth_secret_out,
                      const KeyPair& pair, const std::string& auth_secret) {
     *pair_out = pair;
     *auth_secret_out = auth_secret;
   }
 
  protected:
-  // Tri-state enumaration listing whether the decryption operation is idle
-  // (hasn't started yet), succeeded or failed.
-  enum DecryptionResult {
-    DECRYPTION_IDLE,
-    DECRYPTION_SUCCEEDED,
-    DECRYPTION_FAILED
-  };
-
   // Decrypts the |message| and then synchronously waits until either the
   // success or failure callbacks has been invoked.
   void Decrypt(const IncomingMessage& message) {
-    decryption_result_ = DECRYPTION_IDLE;
     encryption_provider_->DecryptMessage(
         kExampleAppId, message,
-        base::Bind(&GCMEncryptionProviderTest::OnDecryptionSucceeded,
-                   base::Unretained(this)),
-        base::Bind(&GCMEncryptionProviderTest::OnDecryptionFailed,
+        base::Bind(&GCMEncryptionProviderTest::DidDecryptMessage,
                    base::Unretained(this)));
 
     // The encryption keys will be read asynchronously.
     base::RunLoop().RunUntilIdle();
-
-    ASSERT_NE(decryption_result_, DECRYPTION_IDLE);
   }
 
-  DecryptionResult decryption_result() { return decryption_result_; }
+  // Returns the result of the previous decryption operation.
+  GCMEncryptionProvider::DecryptionResult decryption_result() {
+    return decryption_result_;
+  }
 
+  // Returns the message resulting from the previous decryption operation.
   const IncomingMessage& decrypted_message() { return decrypted_message_; }
 
-  GCMEncryptionProvider::DecryptionFailure failure_reason() {
-    return failure_reason_;
-  }
-
   GCMEncryptionProvider* encryption_provider() {
     return encryption_provider_.get();
   }
 
  private:
-  void OnDecryptionSucceeded(const IncomingMessage& message) {
-    decryption_result_ = DECRYPTION_SUCCEEDED;
+  void DidDecryptMessage(GCMEncryptionProvider::DecryptionResult result,
+                         const IncomingMessage& message) {
+    decryption_result_ = result;
     decrypted_message_ = message;
   }
 
-  void OnDecryptionFailed(GCMEncryptionProvider::DecryptionFailure reason) {
-    decryption_result_ = DECRYPTION_FAILED;
-    failure_reason_ = reason;
-  }
-
   base::MessageLoop message_loop_;
   base::ScopedTempDir scoped_temp_dir_;
+  base::HistogramTester histogram_tester_;
 
   scoped_ptr<GCMEncryptionProvider> encryption_provider_;
 
-  DecryptionResult decryption_result_ = DECRYPTION_IDLE;
-  GCMEncryptionProvider::DecryptionFailure failure_reason_ =
-      GCMEncryptionProvider::DECRYPTION_FAILURE_UNKNOWN;
+  GCMEncryptionProvider::DecryptionResult decryption_result_ =
+      GCMEncryptionProvider::DECRYPTION_RESULT_UNENCRYPTED;
 
   IncomingMessage decrypted_message_;
 };
 
 TEST_F(GCMEncryptionProviderTest, IsEncryptedMessage) {
   // Both the Encryption and Encryption-Key headers must be present, and the raw
   // data must be non-empty for a message to be considered encrypted.
 
   IncomingMessage empty_message;
   EXPECT_FALSE(encryption_provider()->IsEncryptedMessage(empty_message));
@@ skipping 17 matching lines @@
                   double_header_with_data_message));
 }
 
 TEST_F(GCMEncryptionProviderTest, VerifiesEncryptionHeaderParsing) {
   // The Encryption header must be parsable and contain valid values.
   // Note that this is more extensively tested in EncryptionHeaderParsersTest.
 
   IncomingMessage invalid_message;
   invalid_message.data["encryption"] = kInvalidEncryptionHeader;
   invalid_message.data["crypto-key"] = kValidCryptoKeyHeader;
+  invalid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(invalid_message));
-  ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_ENCRYPTION_HEADER,
-            failure_reason());
+  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_ENCRYPTION_HEADER,
+            decryption_result());
 
   IncomingMessage valid_message;
   valid_message.data["encryption"] = kValidEncryptionHeader;
   valid_message.data["crypto-key"] = kInvalidCryptoKeyHeader;
+  valid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
-  ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_ENCRYPTION_HEADER,
-            failure_reason());
+  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_ENCRYPTION_HEADER,
+            decryption_result());
 }
 
 TEST_F(GCMEncryptionProviderTest, VerifiesCryptoKeyHeaderParsing) {
   // The Encryption-Key header must be parsable and contain valid values.
   // Note that this is more extensively tested in EncryptionHeaderParsersTest.
 
   IncomingMessage invalid_message;
   invalid_message.data["encryption"] = kValidEncryptionHeader;
   invalid_message.data["crypto-key"] = kInvalidCryptoKeyHeader;
+  invalid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(invalid_message));
-  ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_CRYPTO_KEY_HEADER,
-            failure_reason());
+  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER,
+            decryption_result());
 
   IncomingMessage valid_message;
   valid_message.data["encryption"] = kInvalidEncryptionHeader;
   valid_message.data["crypto-key"] = kValidCryptoKeyHeader;
+  valid_message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(valid_message));
-  ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_FAILURE_INVALID_CRYPTO_KEY_HEADER,
-            failure_reason());
+  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_RESULT_INVALID_CRYPTO_KEY_HEADER,
+            decryption_result());
 }
 
 TEST_F(GCMEncryptionProviderTest, VerifiesExistingKeys) {
   // When both headers are valid, the encryption keys still must be known to
   // the GCM key store before the message can be decrypted.
 
   IncomingMessage message;
   message.data["encryption"] = kValidEncryptionHeader;
   message.data["crypto-key"] = kValidCryptoKeyHeader;
+  message.raw_data = "foo";
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(message));
-  ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_FAILURE_NO_KEYS,
-            failure_reason());
+  EXPECT_EQ(GCMEncryptionProvider::DECRYPTION_RESULT_NO_KEYS,
+            decryption_result());
 
   std::string public_key, auth_secret;
   encryption_provider()->GetEncryptionInfo(
       kExampleAppId,
       base::Bind(&GCMEncryptionProviderTest::DidGetEncryptionInfo,
                  base::Unretained(this), &public_key, &auth_secret));
 
   // Getting (or creating) the public key will be done asynchronously.
   base::RunLoop().RunUntilIdle();
 
   ASSERT_GT(public_key.size(), 0u);
   ASSERT_GT(auth_secret.size(), 0u);
 
   ASSERT_NO_FATAL_FAILURE(Decrypt(message));
-  ASSERT_EQ(DECRYPTION_FAILED, decryption_result());
-  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_FAILURE_NO_KEYS,
-            failure_reason());
+  EXPECT_NE(GCMEncryptionProvider::DECRYPTION_RESULT_NO_KEYS,
+            decryption_result());
 }
 
 TEST_F(GCMEncryptionProviderTest, EncryptionRoundTrip) {
   // Performs a full round-trip of the encryption feature, including getting a
   // public/private key-pair and performing the cryptographic operations. This
   // is more of an integration test than a unit test.
 
   KeyPair pair, server_pair;
   std::string auth_secret, server_authentication;
 
@@ skipping 55 matching lines @@
   encryption_header << "rs=" << base::SizeTToString(record_size) << ";";
   encryption_header << "salt=" << encoded_salt;
 
   message.data["encryption"] = encryption_header.str();
   message.data["crypto-key"] = "dh=" + encoded_key;
 
   ASSERT_TRUE(encryption_provider()->IsEncryptedMessage(message));
 
   // Decrypt the message, and expect everything to go wonderfully well.
   ASSERT_NO_FATAL_FAILURE(Decrypt(message));
-  ASSERT_EQ(DECRYPTION_SUCCEEDED, decryption_result());
+  ASSERT_EQ(GCMEncryptionProvider::DECRYPTION_RESULT_DECRYPTED,
+            decryption_result());
 
   EXPECT_TRUE(decrypted_message().decrypted);
   EXPECT_EQ(kExampleMessage, decrypted_message().raw_data);
 }
 
 }  // namespace gcm