Clean content_settings_pattern_parser.* from unnecessary dependencies.

chrome/common/content_settings_pattern_unittest.cc

 // Copyright (c) 2012 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 "chrome/common/content_settings_pattern.h"
 
+#include "chrome/common/content_settings_component.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 ContentSettingsPattern Pattern(const std::string& str) {
   return ContentSettingsPattern::FromString(str);
 }
 
 }  // namespace
 
-TEST(ContentSettingsPatternTest, RealWorldPatterns) {
+class ContentSettingsPatternTest : public testing::Test {
+ protected:
+  ContentSettingsPatternTest() {
+    InitContentSettingsComponent();
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ContentSettingsPatternTest);
+};
+
+TEST_F(ContentSettingsPatternTest, RealWorldPatterns) {
   // This is the place for real world patterns that unveiled bugs.
   EXPECT_STREQ("[*.]ikea.com",
                Pattern("[*.]ikea.com").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, GURL) {
+TEST_F(ContentSettingsPatternTest, GURL) {
   // Document and verify GURL behavior.
   GURL url("http://mail.google.com:80");
   EXPECT_EQ(-1, url.IntPort());
   EXPECT_EQ("", url.port());
 
   url = GURL("http://mail.google.com");
   EXPECT_EQ(-1, url.IntPort());
   EXPECT_EQ("", url.port());
 
   url = GURL("https://mail.google.com:443");
   EXPECT_EQ(-1, url.IntPort());
   EXPECT_EQ("", url.port());
 
   url = GURL("https://mail.google.com");
   EXPECT_EQ(-1, url.IntPort());
   EXPECT_EQ("", url.port());
 
   url = GURL("http://mail.google.com");
   EXPECT_EQ(-1, url.IntPort());
   EXPECT_EQ("", url.port());
 }
 
-TEST(ContentSettingsPatternTest, FromURL) {
+TEST_F(ContentSettingsPatternTest, FromURL) {
   // NOTICE: When content settings pattern are created from a GURL the following
   // happens:
   // - If the GURL scheme is "http" the scheme wildcard is used. Otherwise the
   //   GURL scheme is used.
   // - A domain wildcard is added to the GURL host.
   // - A port wildcard is used instead of the schemes default port.
   //   In case of non-default ports the specific GURL port is used.
   ContentSettingsPattern pattern = ContentSettingsPattern::FromURL(
       GURL("http://www.youtube.com"));
   EXPECT_TRUE(pattern.IsValid());
@@ skipping 25 matching lines @@
   EXPECT_STREQ("https://127.0.0.1:443", pattern.ToString().c_str());
 
   pattern = ContentSettingsPattern::FromURL(GURL("http://[::1]"));
   EXPECT_TRUE(pattern.IsValid());
 
   pattern = ContentSettingsPattern::FromURL(GURL("file:///foo/bar.html"));
   EXPECT_TRUE(pattern.IsValid());
   EXPECT_EQ("file:///foo/bar.html", pattern.ToString());
 }
 
-TEST(ContentSettingsPatternTest, FilesystemUrls) {
+TEST_F(ContentSettingsPatternTest, FilesystemUrls) {
   ContentSettingsPattern pattern =
       ContentSettingsPattern::FromURL(GURL("http://www.google.com"));
   EXPECT_TRUE(pattern.Matches(
       GURL("filesystem:http://www.google.com/temporary/")));
   EXPECT_TRUE(pattern.Matches(
       GURL("filesystem:http://foo.www.google.com/temporary/")));
   EXPECT_TRUE(pattern.Matches(
       GURL("filesystem:http://www.google.com:80/temporary/")));
   EXPECT_TRUE(pattern.Matches(
       GURL("filesystem:http://www.google.com:81/temporary/")));
@@ skipping 22 matching lines @@
   EXPECT_TRUE(pattern.Matches(GURL("filesystem:file:///temporary/")));
   EXPECT_TRUE(pattern.Matches(GURL("filesystem:file:///temporary/test.txt")));
   EXPECT_TRUE(pattern.Matches(GURL("file:///temporary")));
   EXPECT_FALSE(pattern.Matches(GURL("file://foo/bar")));
   pattern2 =
       ContentSettingsPattern::FromURL(
           GURL("filesystem:file:///persistent/foo2/bar2"));
   EXPECT_EQ(ContentSettingsPattern::IDENTITY, pattern.Compare(pattern2));
 }
 
-TEST(ContentSettingsPatternTest, FromURLNoWildcard) {
+TEST_F(ContentSettingsPatternTest, FromURLNoWildcard) {
   // If no port is specifed GURLs always use the default port for the schemes
   // HTTP and HTTPS. Hence a GURL always carries a port specification either
   // explicitly or implicitly. Therefore if a content settings pattern is
   // created from a GURL with no wildcard, specific values are used for the
   // scheme, host and port part of the pattern.
   // Creating content settings patterns from strings behaves different. Pattern
   // parts that are omitted in pattern specifications (strings), are completed
   // with a wildcard.
   ContentSettingsPattern pattern = ContentSettingsPattern::FromURLNoWildcard(
       GURL("http://www.example.com"));
@@ skipping 21 matching lines @@
   EXPECT_TRUE(pattern.Matches(
       GURL("filesystem:http://www.google.com/persistent/")));
   EXPECT_FALSE(pattern.Matches(
       GURL("filesystem:https://www.google.com/persistent/")));
   EXPECT_FALSE(pattern.Matches(
       GURL("filesystem:https://www.google.com:81/temporary/")));
   EXPECT_FALSE(pattern.Matches(
       GURL("filesystem:https://foo.www.google.com/temporary/")));
 }
 
-TEST(ContentSettingsPatternTest, Wildcard) {
+TEST_F(ContentSettingsPatternTest, Wildcard) {
   EXPECT_TRUE(ContentSettingsPattern::Wildcard().IsValid());
 
   EXPECT_TRUE(ContentSettingsPattern::Wildcard().Matches(
       GURL("http://www.google.com")));
   EXPECT_TRUE(ContentSettingsPattern::Wildcard().Matches(
       GURL("https://www.google.com")));
   EXPECT_TRUE(ContentSettingsPattern::Wildcard().Matches(
       GURL("https://myhost:8080")));
   EXPECT_TRUE(ContentSettingsPattern::Wildcard().Matches(
       GURL("file:///foo/bar.txt")));
 
   EXPECT_STREQ("*", ContentSettingsPattern::Wildcard().ToString().c_str());
 
   EXPECT_EQ(ContentSettingsPattern::IDENTITY,
             ContentSettingsPattern::Wildcard().Compare(
                 ContentSettingsPattern::Wildcard()));
 }
 
-TEST(ContentSettingsPatternTest, TrimEndingDotFromHost) {
+TEST_F(ContentSettingsPatternTest, TrimEndingDotFromHost) {
   EXPECT_TRUE(Pattern("www.example.com").IsValid());
   EXPECT_TRUE(Pattern("www.example.com").Matches(
       GURL("http://www.example.com")));
   EXPECT_TRUE(Pattern("www.example.com").Matches(
       GURL("http://www.example.com.")));
 
   EXPECT_TRUE(Pattern("www.example.com.").IsValid());
   EXPECT_STREQ("www.example.com",
                Pattern("www.example.com.").ToString().c_str());
 
   EXPECT_TRUE(Pattern("www.example.com.") == Pattern("www.example.com"));
 
   EXPECT_TRUE(Pattern(".").IsValid());
   EXPECT_STREQ(".", Pattern(".").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, FromString_WithNoWildcards) {
+TEST_F(ContentSettingsPatternTest, FromString_WithNoWildcards) {
   // HTTP patterns with default port.
   EXPECT_TRUE(Pattern("http://www.example.com:80").IsValid());
   EXPECT_STREQ("http://www.example.com:80",
                Pattern("http://www.example.com:80").ToString().c_str());
   // HTTP patterns with none default port.
   EXPECT_TRUE(Pattern("http://www.example.com:81").IsValid());
   EXPECT_STREQ("http://www.example.com:81",
                Pattern("http://www.example.com:81").ToString().c_str());
 
   // HTTPS patterns with default port.
   EXPECT_TRUE(Pattern("https://www.example.com:443").IsValid());
   EXPECT_STREQ("https://www.example.com:443",
                Pattern("https://www.example.com:443").ToString().c_str());
   // HTTPS patterns with none default port.
   EXPECT_TRUE(Pattern("https://www.example.com:8080").IsValid());
   EXPECT_STREQ("https://www.example.com:8080",
                Pattern("https://www.example.com:8080").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, FromString_FilePatterns) {
+TEST_F(ContentSettingsPatternTest, FromString_FilePatterns) {
   // "/" is an invalid file path.
   EXPECT_FALSE(Pattern("file:///").IsValid());
 
   // Non-empty domains aren't allowed in file patterns.
   EXPECT_FALSE(Pattern("file://foo/").IsValid());
   EXPECT_FALSE(Pattern("file://localhost/foo/bar/test.html").IsValid());
   EXPECT_FALSE(Pattern("file://*").IsValid());
   EXPECT_FALSE(Pattern("file://*/").IsValid());
   EXPECT_FALSE(Pattern("file://*/*").IsValid());
   EXPECT_FALSE(Pattern("file://*/foo/bar/test.html").IsValid());
@@ skipping 20 matching lines @@
   EXPECT_FALSE(Pattern("file:///tmp/test.html").Matches(
       GURL("file:///tmp/other.html")));
   EXPECT_FALSE(Pattern("file:///tmp/test.html").Matches(
       GURL("http://example.org/")));
 
   EXPECT_TRUE(Pattern("file:///*").Matches(GURL("file:///tmp/test.html")));
   EXPECT_TRUE(Pattern("file:///*").Matches(
       GURL("file://localhost/tmp/test.html")));
 }
 
-TEST(ContentSettingsPatternTest, FromString_ExtensionPatterns) {
+TEST_F(ContentSettingsPatternTest, FromString_ExtensionPatterns) {
   EXPECT_TRUE(Pattern("chrome-extension://peoadpeiejnhkmpaakpnompolbglelel/")
       .IsValid());
   EXPECT_EQ("chrome-extension://peoadpeiejnhkmpaakpnompolbglelel/",
       Pattern("chrome-extension://peoadpeiejnhkmpaakpnompolbglelel/")
           .ToString());
   EXPECT_TRUE(Pattern("chrome-extension://peoadpeiejnhkmpaakpnompolbglelel/")
       .Matches(GURL("chrome-extension://peoadpeiejnhkmpaakpnompolbglelel/")));
 }
 
-TEST(ContentSettingsPatternTest, FromString_WithIPAdresses) {
+TEST_F(ContentSettingsPatternTest, FromString_WithIPAdresses) {
   // IPv4
   EXPECT_TRUE(Pattern("192.168.0.1").IsValid());
   EXPECT_STREQ("192.168.1.1", Pattern("192.168.1.1").ToString().c_str());
   EXPECT_TRUE(Pattern("https://192.168.0.1:8080").IsValid());
   EXPECT_STREQ("https://192.168.0.1:8080",
                Pattern("https://192.168.0.1:8080").ToString().c_str());
 
   // Subdomain wildcards should be only valid for hosts, not for IP addresses.
   EXPECT_FALSE(Pattern("[*.]127.0.0.1").IsValid());
 
   // IPv6
   EXPECT_TRUE(Pattern("[::1]").IsValid());
   EXPECT_STREQ("[::1]", Pattern("[::1]").ToString().c_str());
   EXPECT_TRUE(Pattern("https://[::1]:8080").IsValid());
   EXPECT_STREQ("https://[::1]:8080",
                Pattern("https://[::1]:8080").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, FromString_WithWildcards) {
+TEST_F(ContentSettingsPatternTest, FromString_WithWildcards) {
   // Creating content settings patterns from strings completes pattern parts
   // that are omitted in pattern specifications (strings) with a wildcard.
 
   // The wildcard pattern.
   EXPECT_TRUE(Pattern("*").IsValid());
   EXPECT_STREQ("*", Pattern("*").ToString().c_str());
   EXPECT_EQ(ContentSettingsPattern::IDENTITY,
             Pattern("*").Compare(ContentSettingsPattern::Wildcard()));
 
   // Patterns with port wildcard.
@@ skipping 74 matching lines @@
   // Patterns with host wildcard
   EXPECT_TRUE(Pattern("[*.]").IsValid());
   EXPECT_TRUE(Pattern("http://*").IsValid());
   EXPECT_TRUE(Pattern("http://[*.]").IsValid());
   EXPECT_EQ(std::string("http://*"), Pattern("http://[*.]").ToString());
   EXPECT_TRUE(Pattern("http://*:8080").IsValid());
   EXPECT_TRUE(Pattern("*://*").IsValid());
   EXPECT_STREQ("*", Pattern("*://*").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, FromString_Canonicalized) {
+TEST_F(ContentSettingsPatternTest, FromString_Canonicalized) {
   // UTF-8 patterns.
   EXPECT_TRUE(Pattern("[*.]\xC4\x87ira.com").IsValid());
   EXPECT_STREQ("[*.]xn--ira-ppa.com",
                Pattern("[*.]\xC4\x87ira.com").ToString().c_str());
   EXPECT_TRUE(Pattern("\xC4\x87ira.com").IsValid());
   EXPECT_STREQ("xn--ira-ppa.com",
                Pattern("\xC4\x87ira.com").ToString().c_str());
   EXPECT_TRUE(Pattern("file:///\xC4\x87ira.html").IsValid());
   EXPECT_STREQ("file:///%C4%87ira.html",
                Pattern("file:///\xC4\x87ira.html").ToString().c_str());
 
   // File path normalization.
   EXPECT_TRUE(Pattern("file:///tmp/bar/../test.html").IsValid());
   EXPECT_STREQ("file:///tmp/test.html",
                Pattern("file:///tmp/bar/../test.html").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, InvalidPatterns) {
+TEST_F(ContentSettingsPatternTest, InvalidPatterns) {
   // StubObserver expects an empty pattern top be returned as empty string.
   EXPECT_FALSE(ContentSettingsPattern().IsValid());
   EXPECT_STREQ("", ContentSettingsPattern().ToString().c_str());
 
   // Empty pattern string
   EXPECT_FALSE(Pattern(std::string()).IsValid());
   EXPECT_STREQ("", Pattern(std::string()).ToString().c_str());
 
   // Pattern strings with invalid scheme part.
   EXPECT_FALSE(Pattern("ftp://myhost.org").IsValid());
@@ skipping 17 matching lines @@
   EXPECT_FALSE(Pattern("file://").IsValid());
   EXPECT_STREQ("", Pattern("file://").ToString().c_str());
   EXPECT_FALSE(Pattern("file:///foo/bar.html:8080").IsValid());
   EXPECT_STREQ("", Pattern("file:///foo/bar.html:8080").ToString().c_str());
 
   // Host having multiple ending dots.
   EXPECT_FALSE(Pattern("www.example.com..").IsValid());
   EXPECT_STREQ("", Pattern("www.example.com..").ToString().c_str());
 }
 
-TEST(ContentSettingsPatternTest, UnequalOperator) {
+TEST_F(ContentSettingsPatternTest, UnequalOperator) {
   EXPECT_TRUE(Pattern("http://www.foo.com") != Pattern("http://www.foo.com*"));
   EXPECT_TRUE(Pattern("http://www.foo.com*") !=
               ContentSettingsPattern::Wildcard());
 
   EXPECT_TRUE(Pattern("http://www.foo.com") !=
               ContentSettingsPattern::Wildcard());
 
   EXPECT_TRUE(Pattern("http://www.foo.com") != Pattern("www.foo.com"));
   EXPECT_TRUE(Pattern("http://www.foo.com") !=
               Pattern("http://www.foo.com:80"));
 
   EXPECT_FALSE(Pattern("http://www.foo.com") != Pattern("http://www.foo.com"));
   EXPECT_TRUE(Pattern("http://www.foo.com") == Pattern("http://www.foo.com"));
 }
 
-TEST(ContentSettingsPatternTest, Compare) {
+TEST_F(ContentSettingsPatternTest, Compare) {
   // Test identical patterns patterns.
   ContentSettingsPattern pattern1 =
       Pattern("http://www.google.com");
   EXPECT_EQ(ContentSettingsPattern::IDENTITY, pattern1.Compare(pattern1));
   EXPECT_EQ(ContentSettingsPattern::IDENTITY,
             Pattern("http://www.google.com:80").Compare(
                 Pattern("http://www.google.com:80")));
   EXPECT_EQ(ContentSettingsPattern::IDENTITY,
             Pattern("*://[*.]google.com:*").Compare(
                 Pattern("*://[*.]google.com:*")));
@@ skipping 117 matching lines @@
   EXPECT_EQ(ContentSettingsPattern::PREDECESSOR,
             Pattern("mail.google.com").Compare(
                 ContentSettingsPattern::Wildcard()));
   EXPECT_EQ(ContentSettingsPattern::SUCCESSOR,
             ContentSettingsPattern::Wildcard().Compare(
                  Pattern("mail.google.com")));
 }
 
 // Legacy tests to ensure backwards compatibility.
 
-TEST(ContentSettingsPatternTest, PatternSupport_Legacy) {
+TEST_F(ContentSettingsPatternTest, PatternSupport_Legacy) {
   EXPECT_TRUE(Pattern("[*.]example.com").IsValid());
   EXPECT_TRUE(Pattern("example.com").IsValid());
   EXPECT_TRUE(Pattern("192.168.0.1").IsValid());
   EXPECT_TRUE(Pattern("[::1]").IsValid());
   EXPECT_TRUE(
       Pattern("file:///tmp/test.html").IsValid());
   EXPECT_FALSE(Pattern("*example.com").IsValid());
   EXPECT_FALSE(Pattern("example.*").IsValid());
 
   EXPECT_TRUE(
@@ skipping 16 matching lines @@
   EXPECT_FALSE(Pattern("example.com").Matches(
                GURL("http://example.org/")));
   EXPECT_FALSE(
       Pattern("file:///tmp/test.html").Matches(
                GURL("file:///tmp/other.html")));
   EXPECT_FALSE(
       Pattern("file:///tmp/test.html").Matches(
                GURL("http://example.org/")));
 }
 
-TEST(ContentSettingsPatternTest, CanonicalizePattern_Legacy) {
+TEST_F(ContentSettingsPatternTest, CanonicalizePattern_Legacy) {
   // Basic patterns.
   EXPECT_STREQ("[*.]ikea.com", Pattern("[*.]ikea.com").ToString().c_str());
   EXPECT_STREQ("example.com", Pattern("example.com").ToString().c_str());
   EXPECT_STREQ("192.168.1.1", Pattern("192.168.1.1").ToString().c_str());
   EXPECT_STREQ("[::1]", Pattern("[::1]").ToString().c_str());
   EXPECT_STREQ("file:///tmp/file.html",
                Pattern("file:///tmp/file.html").ToString().c_str());
 
   // UTF-8 patterns.
   EXPECT_STREQ("[*.]xn--ira-ppa.com",
                Pattern("[*.]\xC4\x87ira.com").ToString().c_str());
   EXPECT_STREQ("xn--ira-ppa.com",
                Pattern("\xC4\x87ira.com").ToString().c_str());
   EXPECT_STREQ("file:///%C4%87ira.html",
                Pattern("file:///\xC4\x87ira.html").ToString().c_str());
 
   // file:/// normalization.
   EXPECT_STREQ("file:///tmp/test.html",
                Pattern("file:///tmp/bar/../test.html").ToString().c_str());
 
   // Invalid patterns.
   EXPECT_STREQ("", Pattern("*example.com").ToString().c_str());
   EXPECT_STREQ("", Pattern("example.*").ToString().c_str());
   EXPECT_STREQ("", Pattern("*\xC4\x87ira.com").ToString().c_str());
   EXPECT_STREQ("", Pattern("\xC4\x87ira.*").ToString().c_str());
 }