Add disabled origin trial feature list

content/renderer/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/renderer/origin_trials/trial_token_validator.h"
 
+#include <set>
+#include <string>
+
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_util.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
@@ skipping 48 matching lines @@
 
 // Well-formed, but expired, trial token. (Expired in 2001)
 const char kExpiredToken[] =
     "1|Vtzq/H0qMxsMXPThIgGEvI13d3Fd8K3W11/0E+FrJJXqBpx6n/dFkeFkEUsPaP3KeT8PCPF"
     "1zpZ7kVgWYRLpAA==|https://valid.example.com|Frobulate|1000000000";
 
 const char kUnparsableToken[] = "abcde";
 
 class TestContentRendererClient : public content::ContentRendererClient {
  public:
+  // ContentRendererClient methods
   base::StringPiece GetOriginTrialPublicKey() override {
     return base::StringPiece(reinterpret_cast<const char*>(key_),
                              arraysize(kTestPublicKey));
   }
+  bool IsOriginTrialFeatureDisabled(const std::string& feature) override {
+    return disabled_features_.count(feature) > 0;
+  }
+
+  // Test setup methods
   void SetOriginTrialPublicKey(const uint8_t* key) { key_ = key; }
+  void DisableFeature(const std::string& feature) {
+    disabled_features_.insert(feature);
+  }
+ private:
   const uint8_t* key_ = nullptr;
+  std::set<std::string> disabled_features_;
 };
 
 }  // namespace
 
 class TrialTokenValidatorTest : public testing::Test {
  public:
   TrialTokenValidatorTest() {
     SetPublicKey(kTestPublicKey);
     SetRendererClientForTesting(&test_content_renderer_client_);
   }
 
   void SetPublicKey(const uint8_t* key) {
     test_content_renderer_client_.SetOriginTrialPublicKey(key);
   }
 
+  void DisableFeature(const std::string& feature) {
+    test_content_renderer_client_.DisableFeature(feature);
+  }
+
   TrialTokenValidator trial_token_validator_;
 
  private:
   TestContentRendererClient test_content_renderer_client_;
 };
 
 TEST_F(TrialTokenValidatorTest, ValidateValidToken) {
   EXPECT_TRUE(trial_token_validator_.validateToken(
       kSampleToken, kAppropriateOrigin, kAppropriateFeatureName));
 }
@@ skipping 24 matching lines @@
   EXPECT_FALSE(TrialTokenValidator().validateToken(
       kExpiredToken, kAppropriateOrigin, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateValidTokenWithIncorrectKey) {
   SetPublicKey(kTestPublicKey2);
   EXPECT_FALSE(TrialTokenValidator().validateToken(
       kSampleToken, kAppropriateOrigin, kAppropriateFeatureName));
 }
 
+TEST_F(TrialTokenValidatorTest, ValidatorRespectsDisabledFeatures) {
+  // Disable an irrelevant feature; token should still validate
+  DisableFeature(kInappropriateFeatureName);
+  EXPECT_TRUE(trial_token_validator_.validateToken(
+      kSampleToken, kAppropriateOrigin, kAppropriateFeatureName));
+  // Disable the token's feature; it should no longer be valid
+  DisableFeature(kAppropriateFeatureName);
+  EXPECT_FALSE(trial_token_validator_.validateToken(
+      kSampleToken, kAppropriateOrigin, kAppropriateFeatureName));
+}
+
 }  // namespace content