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

content/renderer/origin_trials/trial_token_unittest.cc

Index: content/renderer/origin_trials/trial_token_unittest.cc
diff --git a/content/renderer/origin_trials/trial_token_unittest.cc b/content/renderer/origin_trials/trial_token_unittest.cc
index 2552152c4894dc9764cf874a115bd74bd2ea8a86..787ce2ddbaabfa6f6512d77baa084570a3c09754 100644
--- a/content/renderer/origin_trials/trial_token_unittest.cc
+++ b/content/renderer/origin_trials/trial_token_unittest.cc
@@ -113,7 +113,10 @@ const size_t kNumInvalidTokens = arraysize(kInvalidTokens);
 class TrialTokenTest : public testing::Test {
  public:
   TrialTokenTest()
-      : correct_public_key_(
+      : expected_origin_(GURL(kExpectedOrigin)),
+        invalid_origin_(GURL(kInvalidOrigin)),
+        insecure_origin_(GURL(kInsecureOrigin)),
+        correct_public_key_(
             base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey),
                               arraysize(kTestPublicKey))),
         incorrect_public_key_(
@@ -121,7 +124,7 @@ class TrialTokenTest : public testing::Test {
                               arraysize(kTestPublicKey2))) {}
 
  protected:
-  bool ValidateOrigin(TrialToken* token, const char* origin) {
+  bool ValidateOrigin(TrialToken* token, const url::Origin origin) {
     return token->ValidateOrigin(origin);
   }
 
@@ -138,10 +141,12 @@ class TrialTokenTest : public testing::Test {
     return token->ValidateSignature(public_key);
   }
 
-  const base::StringPiece& correct_public_key() { return correct_public_key_; }
-  const base::StringPiece& incorrect_public_key() {
-    return incorrect_public_key_;
-  }
+  base::StringPiece correct_public_key() { return correct_public_key_; }
+  base::StringPiece incorrect_public_key() { return incorrect_public_key_; }
+
+  const url::Origin expected_origin_;
+  const url::Origin invalid_origin_;
+  const url::Origin insecure_origin_;
 
  private:
   base::StringPiece correct_public_key_;
@@ -168,16 +173,16 @@ TEST_F(TrialTokenTest, ParseValidToken) {
   EXPECT_EQ(kExpectedFeatureName, token->feature_name());
   EXPECT_EQ(kExpectedSignature, token->signature());
   EXPECT_EQ(kExpectedData, token->data());
-  EXPECT_EQ(GURL(kExpectedOrigin), token->origin());
-  EXPECT_EQ(kExpectedExpiry, token->expiry_timestamp());
+  EXPECT_EQ(expected_origin_, token->origin());
+  EXPECT_EQ(base::Time::FromDoubleT(kExpectedExpiry), token->expiry_time());
 }
 
 TEST_F(TrialTokenTest, ValidateValidToken) {
   scoped_ptr<TrialToken> token = TrialToken::Parse(kSampleToken);
   ASSERT_TRUE(token);
-  EXPECT_TRUE(ValidateOrigin(token.get(), kExpectedOrigin));
-  EXPECT_FALSE(ValidateOrigin(token.get(), kInvalidOrigin));
-  EXPECT_FALSE(ValidateOrigin(token.get(), kInsecureOrigin));
+  EXPECT_TRUE(ValidateOrigin(token.get(), expected_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), invalid_origin_));
+  EXPECT_FALSE(ValidateOrigin(token.get(), insecure_origin_));
   EXPECT_TRUE(ValidateFeatureName(token.get(), kExpectedFeatureName));
   EXPECT_FALSE(ValidateFeatureName(token.get(), kInvalidFeatureName));
   EXPECT_FALSE(ValidateFeatureName(
@@ -193,14 +198,14 @@ TEST_F(TrialTokenTest, ValidateValidToken) {
 TEST_F(TrialTokenTest, TokenIsAppropriateForOriginAndFeature) {
   scoped_ptr<TrialToken> token = TrialToken::Parse(kSampleToken);
   ASSERT_TRUE(token);
-  EXPECT_TRUE(token->IsAppropriate(kExpectedOrigin, kExpectedFeatureName));
-  EXPECT_FALSE(token->IsAppropriate(kExpectedOrigin,
+  EXPECT_TRUE(token->IsAppropriate(expected_origin_, kExpectedFeatureName));
+  EXPECT_FALSE(token->IsAppropriate(expected_origin_,
                                     base::ToUpperASCII(kExpectedFeatureName)));
-  EXPECT_FALSE(token->IsAppropriate(kExpectedOrigin,
+  EXPECT_FALSE(token->IsAppropriate(expected_origin_,
                                     base::ToLowerASCII(kExpectedFeatureName)));
-  EXPECT_FALSE(token->IsAppropriate(kInvalidOrigin, kExpectedFeatureName));
-  EXPECT_FALSE(token->IsAppropriate(kInsecureOrigin, kExpectedFeatureName));
-  EXPECT_FALSE(token->IsAppropriate(kExpectedOrigin, kInvalidFeatureName));
+  EXPECT_FALSE(token->IsAppropriate(invalid_origin_, kExpectedFeatureName));
+  EXPECT_FALSE(token->IsAppropriate(insecure_origin_, kExpectedFeatureName));
+  EXPECT_FALSE(token->IsAppropriate(expected_origin_, kInvalidFeatureName));
 }
 
 TEST_F(TrialTokenTest, ValidateValidSignature) {