Make Foreign Fetch an origin trial.

content/common/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/common/origin_trials/trial_token_validator.h"
 
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/origin_trial_policy.h"
+#include "net/http/http_response_headers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebOriginTrialTokenStatus.h"
 #include "url/gurl.h"
 
 namespace content {
 
 namespace {
 
 // This is a sample public key for testing the API. The corresponding private
 // key (use this to generate new samples for this test file) is:
@@ skipping 53 matching lines @@
 // Generate this token with the command (in tools/origin_trials):
 // generate_token.py valid.example.com Frobulate --expire-timestamp=1000000000
 const char kExpiredToken[] =
     "AmHPUIXMaXe9jWW8kJeDFXolVjT93p4XMnK4+jMYd2pjqtFcYB1bUmdD8PunQKM+"
     "RrOtlAwa0gPqqn+A8GTD3AQAAABZeyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l"
     "eGFtcGxlLmNvbTo0NDMiLCAiZmVhdHVyZSI6ICJGcm9idWxhdGUiLCAiZXhwaXJ5"
     "IjogMTAwMDAwMDAwMH0=";
 
 const char kUnparsableToken[] = "abcde";
 
+// Well-formed token, for an insecure origin.
+// Generate this token with the command (in tools/origin_trials):
+// generate_token.py http://valid.example.com Frobulate
+// --expire-timestamp=2000000000
+const char kInsecureOriginToken[] =
+    "AjfC47H1q8/Ho5ALFkjkwf9CBK6oUUeRTlFc50Dj+eZEyGGKFIY2WTxMBfy8cLc3"
+    "E0nmFroDA3OmABmO5jMCFgkAAABXeyJvcmlnaW4iOiAiaHR0cDovL3ZhbGlkLmV4"
+    "YW1wbGUuY29tOjgwIiwgImZlYXR1cmUiOiAiRnJvYnVsYXRlIiwgImV4cGlyeSI6"
+    "IDIwMDAwMDAwMDB9";
+
 class TestOriginTrialPolicy : public OriginTrialPolicy {
  public:
   base::StringPiece GetPublicKey() const override {
     return base::StringPiece(reinterpret_cast<const char*>(key_),
                              arraysize(kTestPublicKey));
   }
   bool IsFeatureDisabled(base::StringPiece feature) const override {
     return disabled_features_.count(feature.as_string()) > 0;
   }
 
@@ skipping 26 matching lines @@
   TestOriginTrialPolicy origin_trial_policy_;
 };
 
 }  // namespace
 
 class TrialTokenValidatorTest : public testing::Test {
  public:
   TrialTokenValidatorTest()
       : appropriate_origin_(GURL(kAppropriateOrigin)),
         inappropriate_origin_(GURL(kInappropriateOrigin)),
-        insecure_origin_(GURL(kInsecureOrigin)) {
+        insecure_origin_(GURL(kInsecureOrigin)),
+        response_headers_(new net::HttpResponseHeaders("")) {
     SetPublicKey(kTestPublicKey);
     SetContentClient(&test_content_client_);
   }
 
   ~TrialTokenValidatorTest() override { SetContentClient(nullptr); }
 
   void SetPublicKey(const uint8_t* key) {
     test_content_client_.SetOriginTrialPublicKey(key);
   }
 
   void DisableFeature(const std::string& feature) {
     test_content_client_.DisableFeature(feature);
   }
 
   const url::Origin appropriate_origin_;
   const url::Origin inappropriate_origin_;
   const url::Origin insecure_origin_;
 
+  scoped_refptr<net::HttpResponseHeaders> response_headers_;
+
  private:
   TestContentClient test_content_client_;
 };
 
 TEST_F(TrialTokenValidatorTest, ValidateValidToken) {
   std::string feature;
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::Success,
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
   EXPECT_EQ(kAppropriateFeatureName, feature);
@@ skipping 46 matching lines @@
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
   EXPECT_EQ(kAppropriateFeatureName, feature);
   // Disable the token's feature; it should no longer be valid
   DisableFeature(kAppropriateFeatureName);
   EXPECT_EQ(blink::WebOriginTrialTokenStatus::FeatureDisabled,
             TrialTokenValidator::ValidateToken(kSampleToken,
                                                appropriate_origin_, &feature));
 }
 
+TEST_F(TrialTokenValidatorTest, ValidateRequestInsecure) {
+  response_headers_->AddHeader(std::string("Origin-Trial: ") +
+                               kInsecureOriginToken);
+  EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kInsecureOrigin), response_headers_.get(), kAppropriateFeatureName));
+}
+
+TEST_F(TrialTokenValidatorTest, ValidateRequestValidToken) {
+  response_headers_->AddHeader(std::string("Origin-Trial: ") + kSampleToken);
+  EXPECT_TRUE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kAppropriateOrigin), response_headers_.get(),
+      kAppropriateFeatureName));
+}
+
+TEST_F(TrialTokenValidatorTest, ValidateRequestNoTokens) {
+  EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kAppropriateOrigin), response_headers_.get(),
+      kAppropriateFeatureName));
+}
+
+TEST_F(TrialTokenValidatorTest, ValidateRequestMultipleHeaders) {
+  response_headers_->AddHeader(std::string("Origin-Trial: ") + kSampleToken);
+  response_headers_->AddHeader(std::string("Origin-Trial: ") + kExpiredToken);
+  EXPECT_TRUE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kAppropriateOrigin), response_headers_.get(),
+      kAppropriateFeatureName));
+  EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kAppropriateOrigin), response_headers_.get(),
+      kInappropriateFeatureName));
+  EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kInappropriateOrigin), response_headers_.get(),
+      kAppropriateFeatureName));
+}
+
+TEST_F(TrialTokenValidatorTest, ValidateRequestMultipleHeaderValues) {
+  response_headers_->AddHeader(std::string("Origin-Trial: ") + kExpiredToken +
+                               ", " + kSampleToken);
+  EXPECT_TRUE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kAppropriateOrigin), response_headers_.get(),
+      kAppropriateFeatureName));
+  EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kAppropriateOrigin), response_headers_.get(),
+      kInappropriateFeatureName));
+  EXPECT_FALSE(TrialTokenValidator::RequestEnablesFeature(
+      GURL(kInappropriateOrigin), response_headers_.get(),
+      kAppropriateFeatureName));
+}
+
 }  // namespace content