Collect UMA data for Origin Trials

content/common/origin_trials/trial_token_unittest.cc

Index: content/common/origin_trials/trial_token_unittest.cc
diff --git a/content/common/origin_trials/trial_token_unittest.cc b/content/common/origin_trials/trial_token_unittest.cc
index ebb5b05a4cf55084d2fccfb2bfe71c1773c3d5be..9fff85cf88a660b4c5392c0270599801a508465c 100644
--- a/content/common/origin_trials/trial_token_unittest.cc
+++ b/content/common/origin_trials/trial_token_unittest.cc
@@ -153,10 +153,18 @@ class TrialTokenTest : public testing::TestWithParam<const char*> {
                               arraysize(kTestPublicKey2))) {}
 
  protected:
-  std::unique_ptr<std::string> Extract(const std::string& token_text,
-                                       base::StringPiece public_key) {
-    return TrialToken::Extract(token_text, public_key);
+  TrialTokenStatus Extract(const std::string& token_text,
+                           base::StringPiece public_key,
+                           std::string* token_payload) {
+    return TrialToken::Extract(token_text, public_key, token_payload);
   }
+
+  TrialTokenStatus ExtractIgnorePayload(const std::string& token_text,
+                                        base::StringPiece public_key) {
+    std::string token_payload;
+    return Extract(token_text, public_key, &token_payload);
+  }
+
   std::unique_ptr<TrialToken> Parse(const std::string& token_payload) {
     return TrialToken::Parse(token_payload);
   }
@@ -196,46 +204,48 @@ class TrialTokenTest : public testing::TestWithParam<const char*> {
 // Test verification of signature and extraction of token JSON from signed
 // token.
 TEST_F(TrialTokenTest, ValidateValidSignature) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kSampleToken, correct_public_key());
-  ASSERT_TRUE(token_payload);
-  EXPECT_STREQ(kSampleTokenJSON, token_payload.get()->c_str());
+  std::string token_payload;
+  TrialTokenStatus status =
+      Extract(kSampleToken, correct_public_key(), &token_payload);
+  ASSERT_EQ(TRIAL_TOKEN_STATUS_SUCCESS, status);
+  EXPECT_STREQ(kSampleTokenJSON, token_payload.c_str());
 }
 
 TEST_F(TrialTokenTest, ValidateInvalidSignature) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kInvalidSignatureToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kInvalidSignatureToken, correct_public_key());
+  // TODO(chasej): Recreate the invalid token, and change to
+  // TRIAL_TOKEN_STATUS_INVALID_SIGNATURE
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateSignatureWithIncorrectKey) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kSampleToken, incorrect_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kSampleToken, incorrect_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_INVALID_SIGNATURE, status);
 }
 
 TEST_F(TrialTokenTest, ValidateEmptyToken) {
-  std::unique_ptr<std::string> token_payload =
-      Extract("", correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status = ExtractIgnorePayload("", correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateShortToken) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kTruncatedToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kTruncatedToken, correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateUnsupportedVersion) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kIncorrectVersionToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kIncorrectVersionToken, correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 TEST_F(TrialTokenTest, ValidateSignatureWithIncorrectLength) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kIncorrectLengthToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  TrialTokenStatus status =
+      ExtractIgnorePayload(kIncorrectLengthToken, correct_public_key());
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 // Test parsing of fields from JSON token.
@@ -279,22 +289,54 @@ TEST_F(TrialTokenTest, ValidateValidToken) {
 TEST_F(TrialTokenTest, TokenIsValidForFeature) {
   std::unique_ptr<TrialToken> token = Parse(kSampleTokenJSON);
   ASSERT_TRUE(token);
-  EXPECT_TRUE(token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
-                                       valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(
-      expected_origin_, base::ToUpperASCII(kExpectedFeatureName),
-      valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(
-      expected_origin_, base::ToLowerASCII(kExpectedFeatureName),
-      valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(invalid_origin_, kExpectedFeatureName,
-                                        valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(insecure_origin_, kExpectedFeatureName,
-                                        valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(expected_origin_, kInvalidFeatureName,
-                                        valid_timestamp_));
-  EXPECT_FALSE(token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
-                                        invalid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_SUCCESS,
+            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            token->IsValidForFeature(expected_origin_,
+                                     base::ToUpperASCII(kExpectedFeatureName),
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            token->IsValidForFeature(expected_origin_,
+                                     base::ToLowerASCII(kExpectedFeatureName),
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_ORIGIN,
+            token->IsValidForFeature(invalid_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_ORIGIN,
+            token->IsValidForFeature(insecure_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_WRONG_FEATURE,
+            token->IsValidForFeature(expected_origin_, kInvalidFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_EXPIRED,
+            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
+                                     invalid_timestamp_));
+}
+
+// Test overall extraction, to ensure output status matches returned token
+TEST_F(TrialTokenTest, ExtractValidToken) {
+  TrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kSampleToken, correct_public_key(), &status);
+  EXPECT_TRUE(token);
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_SUCCESS, status);
+}
+
+TEST_F(TrialTokenTest, ExtractInvalidSignature) {
+  TrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kSampleToken, incorrect_public_key(), &status);
+  EXPECT_FALSE(token);
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_INVALID_SIGNATURE, status);
+}
+
+TEST_F(TrialTokenTest, ExtractMalformedToken) {
+  TrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kIncorrectLengthToken, correct_public_key(), &status);
+  EXPECT_FALSE(token);
+  EXPECT_EQ(TRIAL_TOKEN_STATUS_MALFORMED, status);
 }
 
 }  // namespace content