Collect UMA data for Origin Trials

content/common/origin_trials/trial_token_validator_unittest.cc

 // Copyright 2016 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 "content/common/origin_trials/trial_token_validator.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
@@ skipping 102 matching lines @@
 
   const url::Origin appropriate_origin_;
   const url::Origin inappropriate_origin_;
   const url::Origin insecure_origin_;
 
  private:
   TestContentClient test_content_client_;
 };
 
 TEST_F(TrialTokenValidatorTest, ValidateValidToken) {
-  EXPECT_TRUE(TrialTokenValidator::ValidateToken(
-      kSampleToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_SUCCESS,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateOrigin) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kSampleToken, inappropriate_origin_, kAppropriateFeatureName));
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kSampleToken, insecure_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_ORIGIN,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, inappropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_ORIGIN,
+            TrialTokenValidator::ValidateToken(kSampleToken, insecure_origin_,
+                                               kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateFeature) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kSampleToken, appropriate_origin_, kInappropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, appropriate_origin_, kInappropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInvalidSignature) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kInvalidSignatureToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_INVALID_SIGNATURE,
+            TrialTokenValidator::ValidateToken(kInvalidSignatureToken,
+                                               appropriate_origin_,
+                                               kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateUnparsableToken) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kUnparsableToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED,
+            TrialTokenValidator::ValidateToken(kUnparsableToken,
+                                               appropriate_origin_,
+                                               kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateExpiredToken) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kExpiredToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_EXPIRED,
+            TrialTokenValidator::ValidateToken(
+                kExpiredToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateValidTokenWithIncorrectKey) {
   SetPublicKey(kTestPublicKey2);
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kSampleToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_INVALID_SIGNATURE,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 }  // namespace content