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..b3be991c75483690cd312296f8f6286fef05eecd 100644
--- a/content/common/origin_trials/trial_token_unittest.cc
+++ b/content/common/origin_trials/trial_token_unittest.cc
@@ -12,6 +12,7 @@
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/platform/WebOriginTrialTokenStatus.h"
 #include "url/gurl.h"
 
 namespace content {
@@ -75,10 +76,10 @@ double kInvalidTimestamp = 1458766278.0;
 
 // Well-formed trial token with an invalid signature.
 const char* kInvalidSignatureToken =
-    "AYeNXSDktgG9p4ns5B1WKsLq2TytMxfR4whfbi+oyT0rXyzh+qXYfxbDMGmyjU2Z"
-    "lEJ16vQObMXJoOaYUqd8xwkAAABZeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l"
-    "eGFtcGxlLmNvbTo0NDMiLCAiZmVhdHVyZSI6ICJGcm9idWxhdGUiLCAiZXhwaXJ5"
-    "IjogMTQ1ODc2NjI3N30=";
+    "Ap+Q/Qm0ELadZql+dlEGSwnAVsFZKgCEtUZg8idQC3uekkIeSZIY1tftoYdrwhqj"
+    "7FO5L22sNvkZZnacLvmfNwsAAABaeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l"
+    "eGFtcGxlLmNvbTo0NDMiLCAiZmVhdHVyZSI6ICJGcm9idWxhdGV4IiwgImV4cGly"
+    "eSI6IDE0NTg3NjYyNzd9";
 
 // Trial token truncated in the middle of the length field; too short to
 // possibly be valid.
@@ -153,10 +154,19 @@ 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);
+  blink::WebOriginTrialTokenStatus Extract(const std::string& token_text,
+                                           base::StringPiece public_key,
+                                           std::string* token_payload) {
+    return TrialToken::Extract(token_text, public_key, token_payload);
   }
+
+  blink::WebOriginTrialTokenStatus 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 +206,47 @@ 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;
+  blink::WebOriginTrialTokenStatus status =
+      Extract(kSampleToken, correct_public_key(), &token_payload);
+  ASSERT_EQ(blink::WebOriginTrialTokenStatus::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);
+  blink::WebOriginTrialTokenStatus status =
+      ExtractIgnorePayload(kInvalidSignatureToken, correct_public_key());
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature, status);
 }
 
 TEST_F(TrialTokenTest, ValidateSignatureWithIncorrectKey) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kSampleToken, incorrect_public_key());
-  ASSERT_FALSE(token_payload);
+  blink::WebOriginTrialTokenStatus status =
+      ExtractIgnorePayload(kSampleToken, incorrect_public_key());
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature, status);
 }
 
 TEST_F(TrialTokenTest, ValidateEmptyToken) {
-  std::unique_ptr<std::string> token_payload =
-      Extract("", correct_public_key());
-  ASSERT_FALSE(token_payload);
+  blink::WebOriginTrialTokenStatus status =
+      ExtractIgnorePayload("", correct_public_key());
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Malformed, status);
 }
 
 TEST_F(TrialTokenTest, ValidateShortToken) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kTruncatedToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  blink::WebOriginTrialTokenStatus status =
+      ExtractIgnorePayload(kTruncatedToken, correct_public_key());
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Malformed, status);
 }
 
 TEST_F(TrialTokenTest, ValidateUnsupportedVersion) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kIncorrectVersionToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  blink::WebOriginTrialTokenStatus status =
+      ExtractIgnorePayload(kIncorrectVersionToken, correct_public_key());
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongVersion, status);
 }
 
 TEST_F(TrialTokenTest, ValidateSignatureWithIncorrectLength) {
-  std::unique_ptr<std::string> token_payload =
-      Extract(kIncorrectLengthToken, correct_public_key());
-  ASSERT_FALSE(token_payload);
+  blink::WebOriginTrialTokenStatus status =
+      ExtractIgnorePayload(kIncorrectLengthToken, correct_public_key());
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Malformed, status);
 }
 
 // Test parsing of fields from JSON token.
@@ -279,22 +290,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(blink::WebOriginTrialTokenStatus::Success,
+            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongFeature,
+            token->IsValidForFeature(expected_origin_,
+                                     base::ToUpperASCII(kExpectedFeatureName),
+                                     valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongFeature,
+            token->IsValidForFeature(expected_origin_,
+                                     base::ToLowerASCII(kExpectedFeatureName),
+                                     valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            token->IsValidForFeature(invalid_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
+            token->IsValidForFeature(insecure_origin_, kExpectedFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongFeature,
+            token->IsValidForFeature(expected_origin_, kInvalidFeatureName,
+                                     valid_timestamp_));
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Expired,
+            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
+                                     invalid_timestamp_));
+}
+
+// Test overall extraction, to ensure output status matches returned token
+TEST_F(TrialTokenTest, ExtractValidToken) {
+  blink::WebOriginTrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kSampleToken, correct_public_key(), &status);
+  EXPECT_TRUE(token);
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success, status);
+}
+
+TEST_F(TrialTokenTest, ExtractInvalidSignature) {
+  blink::WebOriginTrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kSampleToken, incorrect_public_key(), &status);
+  EXPECT_FALSE(token);
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::InvalidSignature, status);
+}
+
+TEST_F(TrialTokenTest, ExtractMalformedToken) {
+  blink::WebOriginTrialTokenStatus status;
+  std::unique_ptr<TrialToken> token =
+      TrialToken::From(kIncorrectLengthToken, correct_public_key(), &status);
+  EXPECT_FALSE(token);
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::Malformed, status);
 }
 
 }  // namespace content