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"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "content/public/common/content_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebOriginTrialTokenStatus.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 // This is a sample public key for testing the API. The corresponding private
 // key (use this to generate new samples for this test file) is:
 //
 //  0x83, 0x67, 0xf4, 0xcd, 0x2a, 0x1f, 0x0e, 0x04, 0x0d, 0x43, 0x13,
@@ skipping 88 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(blink::WebOriginTrialTokenStatus::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(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, inappropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            TrialTokenValidator::ValidateToken(kSampleToken, insecure_origin_,
+                                               kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateFeature) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kSampleToken, appropriate_origin_, kInappropriateFeatureName));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongFeature,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, appropriate_origin_, kInappropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInvalidSignature) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kInvalidSignatureToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature,
+            TrialTokenValidator::ValidateToken(kInvalidSignatureToken,
+                                               appropriate_origin_,
+                                               kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateUnparsableToken) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kUnparsableToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Malformed,
+            TrialTokenValidator::ValidateToken(kUnparsableToken,
+                                               appropriate_origin_,
+                                               kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateExpiredToken) {
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kExpiredToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Expired,
+            TrialTokenValidator::ValidateToken(
+                kExpiredToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateValidTokenWithIncorrectKey) {
   SetPublicKey(kTestPublicKey2);
-  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
-      kSampleToken, appropriate_origin_, kAppropriateFeatureName));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature,
+            TrialTokenValidator::ValidateToken(
+                kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 }  // namespace content