Simplify OriginTrialContext and the way it validates tokens.

content/common/origin_trials/trial_token_unittest.cc

 // Copyright 2015 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.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/strings/string_piece.h"
@@ skipping 269 matching lines @@
   EXPECT_TRUE(ValidateFeatureName(token.get(), kExpectedFeatureName));
   EXPECT_FALSE(ValidateFeatureName(token.get(), kInvalidFeatureName));
   EXPECT_FALSE(ValidateFeatureName(
       token.get(), base::ToUpperASCII(kExpectedFeatureName).c_str()));
   EXPECT_FALSE(ValidateFeatureName(
       token.get(), base::ToLowerASCII(kExpectedFeatureName).c_str()));
   EXPECT_TRUE(ValidateDate(token.get(), valid_timestamp_));
   EXPECT_FALSE(ValidateDate(token.get(), invalid_timestamp_));
 }
 
-TEST_F(TrialTokenTest, TokenIsValidForFeature) {
+TEST_F(TrialTokenTest, TokenIsValid) {
   std::unique_ptr<TrialToken> token = Parse(kSampleTokenJSON);
   ASSERT_TRUE(token);
   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_));
+            token->IsValid(expected_origin_, valid_timestamp_));
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::WrongOrigin,
-            token->IsValidForFeature(invalid_origin_, kExpectedFeatureName,
-                                     valid_timestamp_));
+            token->IsValid(invalid_origin_, 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_));
+            token->IsValid(insecure_origin_, valid_timestamp_));
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Expired,
-            token->IsValidForFeature(expected_origin_, kExpectedFeatureName,
-                                     invalid_timestamp_));
+            token->IsValid(expected_origin_, 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