Move trial token code to content/common.

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/renderer/origin_trials/trial_token_validator.h"
+#include "content/common/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 "content/public/common/content_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:
 //
@@ skipping 41 matching lines @@
     "1|CO8hDne98QeFeOJ0DbRZCBN3uE0nyaPgaLlkYhSWnbRoDfEAg+TXELaYfQPfEvKYFauBg/h"
     "nxmba765hz0mXMc==|https://valid.example.com|Frobulate|2000000000";
 
 // 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 {
+class TestContentClient : public ContentClient {
  public:
   base::StringPiece GetOriginTrialPublicKey() override {
     return base::StringPiece(reinterpret_cast<const char*>(key_),
                              arraysize(kTestPublicKey));
   }
   void SetOriginTrialPublicKey(const uint8_t* key) { key_ = key; }
   const uint8_t* key_ = nullptr;
 };
 
 }  // namespace
 
 class TrialTokenValidatorTest : public testing::Test {
  public:
   TrialTokenValidatorTest()
       : appropriate_origin_(GURL(kAppropriateOrigin)),
         inappropriate_origin_(GURL(kInappropriateOrigin)),
         insecure_origin_(GURL(kInsecureOrigin)) {
     SetPublicKey(kTestPublicKey);
-    SetRendererClientForTesting(&test_content_renderer_client_);
+    SetContentClient(&test_content_client_);
   }
 
+  ~TrialTokenValidatorTest() override { SetContentClient(nullptr); }
+
   void SetPublicKey(const uint8_t* key) {
-    test_content_renderer_client_.SetOriginTrialPublicKey(key);
+    test_content_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_;
+  TestContentClient test_content_client_;
 };
 
 TEST_F(TrialTokenValidatorTest, ValidateValidToken) {
-  EXPECT_TRUE(trial_token_validator_.validateToken(
+  EXPECT_TRUE(TrialTokenValidator::ValidateToken(
       kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateOrigin) {
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kSampleToken, inappropriate_origin_, kAppropriateFeatureName));
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kSampleToken, insecure_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInappropriateFeature) {
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kSampleToken, appropriate_origin_, kInappropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateInvalidSignature) {
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kInvalidSignatureToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateUnparsableToken) {
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kUnparsableToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateExpiredToken) {
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kExpiredToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 TEST_F(TrialTokenValidatorTest, ValidateValidTokenWithIncorrectKey) {
   SetPublicKey(kTestPublicKey2);
-  EXPECT_FALSE(TrialTokenValidator().validateToken(
+  EXPECT_FALSE(TrialTokenValidator::ValidateToken(
       kSampleToken, appropriate_origin_, kAppropriateFeatureName));
 }
 
 }  // namespace content