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

content/renderer/origin_trials/trial_token_unittest.cc

 // Copyright 2015 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.h"
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_util.h"
 #include "base/test/simple_test_clock.h"
 #include "base/time/time.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 82 matching lines @@
     "1|Signature|abcdef|FeatureName|1458766277",
     "1|Signature|data:text/plain,abcdef|FeatureName|1458766277",
     "1|Signature|javascript:alert(1)|FeatureName|1458766277"};
 const size_t kNumInvalidTokens = arraysize(kInvalidTokens);
 
 }  // namespace
 
 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_(
             base::StringPiece(reinterpret_cast<const char*>(kTestPublicKey2),
                               arraysize(kTestPublicKey2))) {}
 
  protected:
-  bool ValidateOrigin(TrialToken* token, const char* origin) {
+  bool ValidateOrigin(TrialToken* token, const url::Origin origin) {
     return token->ValidateOrigin(origin);
   }
 
   bool ValidateFeatureName(TrialToken* token, const char* feature_name) {
     return token->ValidateFeatureName(feature_name);
   }
 
   bool ValidateDate(TrialToken* token, const base::Time& now) {
     return token->ValidateDate(now);
   }
 
   bool ValidateSignature(TrialToken* token,
                          const base::StringPiece& public_key) {
     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_;
   base::StringPiece incorrect_public_key_;
 };
 
 TEST_F(TrialTokenTest, ParseEmptyString) {
   scoped_ptr<TrialToken> empty_token = TrialToken::Parse("");
   EXPECT_FALSE(empty_token);
 }
 
 TEST_F(TrialTokenTest, ParseInvalidStrings) {
   for (size_t i = 0; i < kNumInvalidTokens; ++i) {
     scoped_ptr<TrialToken> empty_token = TrialToken::Parse(kInvalidTokens[i]);
     EXPECT_FALSE(empty_token) << "Invalid trial token should not parse: "
                               << kInvalidTokens[i];
   }
 }
 
 TEST_F(TrialTokenTest, ParseValidToken) {
   scoped_ptr<TrialToken> token = TrialToken::Parse(kSampleToken);
   ASSERT_TRUE(token);
   EXPECT_EQ(kExpectedVersion, token->version());
   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(
       token.get(), base::ToUpperASCII(kExpectedFeatureName).c_str()));
   EXPECT_FALSE(ValidateFeatureName(
       token.get(), base::ToLowerASCII(kExpectedFeatureName).c_str()));
   EXPECT_TRUE(
       ValidateDate(token.get(), base::Time::FromDoubleT(kValidTimestamp)));
   EXPECT_FALSE(
       ValidateDate(token.get(), base::Time::FromDoubleT(kInvalidTimestamp)));
 }
 
 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) {
   scoped_ptr<TrialToken> token = TrialToken::Parse(kSampleToken);
   ASSERT_TRUE(token);
   EXPECT_TRUE(ValidateSignature(token.get(), correct_public_key()));
 }
 
 TEST_F(TrialTokenTest, ValidateInvalidSignature) {
   scoped_ptr<TrialToken> token = TrialToken::Parse(kInvalidSignatureToken);
@@ skipping 14 matching lines @@
   EXPECT_FALSE(token->IsValid(base::Time::FromDoubleT(kValidTimestamp),
                               incorrect_public_key()));
 }
 
 TEST_F(TrialTokenTest, ValidateWhenNotExpired) {
   scoped_ptr<TrialToken> token = TrialToken::Parse(kSampleToken);
   ASSERT_TRUE(token);
 }
 
 }  // namespace content