Cleanup TrialToken in preparation of moving it to content/common.

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 "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"
+#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:
 //
 //  0x83, 0x67, 0xf4, 0xcd, 0x2a, 0x1f, 0x0e, 0x04, 0x0d, 0x43, 0x13,
 //  0x4c, 0x67, 0xc4, 0xf4, 0x28, 0xc9, 0x90, 0x15, 0x02, 0xe2, 0xba,
@@ skipping 53 matching lines @@
                              arraysize(kTestPublicKey));
   }
   void SetOriginTrialPublicKey(const uint8_t* key) { key_ = key; }
   const uint8_t* key_ = nullptr;
 };
 
 }  // namespace
 
 class TrialTokenValidatorTest : public testing::Test {
  public:
-  TrialTokenValidatorTest() {
+  TrialTokenValidatorTest()
+      : appropriate_origin_(GURL(kAppropriateOrigin)),
+        inappropriate_origin_(GURL(kInappropriateOrigin)),
+        insecure_origin_(GURL(kInsecureOrigin)) {
     SetPublicKey(kTestPublicKey);
     SetRendererClientForTesting(&test_content_renderer_client_);
   }
 
   void SetPublicKey(const uint8_t* key) {
     test_content_renderer_client_.SetOriginTrialPublicKey(key);
   }
 
   TrialTokenValidator trial_token_validator_;
+  const url::Origin appropriate_origin_;
+  const url::Origin inappropriate_origin_;
+  const url::Origin insecure_origin_;
 
  private:
   TestContentRendererClient test_content_renderer_client_;
 };
 
 TEST_F(TrialTokenValidatorTest, ValidateValidToken) {
   EXPECT_TRUE(trial_token_validator_.validateToken(
-      kSampleToken, kAppropriateOrigin, kAppropriateFeatureName));
+      kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateOrigin) {
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kSampleToken, kInappropriateOrigin, kAppropriateFeatureName));
+      kSampleToken, inappropriate_origin_, kAppropriateFeatureName));
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kSampleToken, kInsecureOrigin, kAppropriateFeatureName));
+      kSampleToken, insecure_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateFeature) {
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kSampleToken, kAppropriateOrigin, kInappropriateFeatureName));
+      kSampleToken, appropriate_origin_, kInappropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInvalidSignature) {
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kInvalidSignatureToken, kAppropriateOrigin, kAppropriateFeatureName));
+      kInvalidSignatureToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateUnparsableToken) {
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kUnparsableToken, kAppropriateOrigin, kAppropriateFeatureName));
+      kUnparsableToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateExpiredToken) {
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kExpiredToken, kAppropriateOrigin, kAppropriateFeatureName));
+      kExpiredToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateValidTokenWithIncorrectKey) {
   SetPublicKey(kTestPublicKey2);
   EXPECT_FALSE(TrialTokenValidator().validateToken(
-      kSampleToken, kAppropriateOrigin, kAppropriateFeatureName));
+      kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 }  // namespace content