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..fad06375d7696a222ae7dff0a040c1749a063a1f 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 {
@@ -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,49 @@ 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());
+  // TODO(chasej): Recreate the invalid token, and change to
+  // blink::WebOriginTrialTokenStatus::InvalidSignature
+  EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongVersion, status);

[iclelland, 2016/05/02 16:17:55]

Let's fix this todo in this CL. It shouldn't be hard to recreate; let me know if
you want me to do it.

[chasej, 2016/05/03 16:55:10]

Yes, it was my intent to fix in this CL, once the bigger changes were in good
shape. Done.

 }
 
 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 +292,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