Cleanup: cpplint from /extensions

extensions/common/url_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 "base/memory/scoped_ptr.h"
 #include "extensions/common/url_pattern.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
@@ skipping 36 matching lines @@
   }
 
   {
     // Cannot use a C string, because this contains a null byte.
     std::string null_host("http://\0www/", 12);
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(URLPattern::PARSE_ERROR_INVALID_HOST,
               pattern.Parse(null_host))
         << null_host;
   }
-};
+}
 
 TEST(ExtensionURLPatternTest, Ports) {
   const struct {
     const char* pattern;
     URLPattern::ParseResult expected_result;
     const char* expected_port;
   } kTestPatterns[] = {
     { "http://foo:1234/", URLPattern::PARSE_SUCCESS, "1234" },
     { "http://foo:1234/bar", URLPattern::PARSE_SUCCESS, "1234" },
     { "http://*.foo:1234/", URLPattern::PARSE_SUCCESS, "1234" },
@@ skipping 16 matching lines @@
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kTestPatterns); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(kTestPatterns[i].expected_result,
               pattern.Parse(kTestPatterns[i].pattern))
         << "Got unexpected result for URL pattern: "
         << kTestPatterns[i].pattern;
     EXPECT_EQ(kTestPatterns[i].expected_port, pattern.port())
         << "Got unexpected port for URL pattern: " << kTestPatterns[i].pattern;
   }
-};
+}
 
 // all pages for a given scheme
 TEST(ExtensionURLPatternTest, Match1) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://*/*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
@@ skipping 72 matching lines @@
   URLPattern pattern(kAllSchemes);
   // allowed, but useless
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("http://*.0.0.1/*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("0.0.1", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   // Subdomain matching is never done if the argument has an IP address host.
   EXPECT_FALSE(pattern.MatchesURL(GURL("http://127.0.0.1")));
-};
+}
 
 // unicode
 TEST(ExtensionURLPatternTest, Match8) {
   URLPattern pattern(kAllSchemes);
   // The below is the ASCII encoding of the following URL:
   // http://*.\xe1\x80\xbf/a\xc2\x81\xe1*
   EXPECT_EQ(URLPattern::PARSE_SUCCESS,
             pattern.Parse("http://*.xn--gkd/a%C2%81%E1*"));
   EXPECT_EQ("http", pattern.scheme());
   EXPECT_EQ("xn--gkd", pattern.host());
   EXPECT_TRUE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/a%C2%81%E1*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("http://abc.\xe1\x80\xbf/a\xc2\x81\xe1xyz")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("http://\xe1\x80\xbf/a\xc2\x81\xe1\xe1")));
-};
+}
 
 // chrome://
 TEST(ExtensionURLPatternTest, Match9) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("chrome://favicon/*"));
   EXPECT_EQ("chrome", pattern.scheme());
   EXPECT_EQ("favicon", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/https://google.com")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("chrome://history")));
-};
+}
 
 // *://
 TEST(ExtensionURLPatternTest, Match10) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("*://*/*"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_FALSE(pattern.MatchesScheme("chrome"));
   EXPECT_FALSE(pattern.MatchesScheme("file"));
   EXPECT_FALSE(pattern.MatchesScheme("ftp"));
   EXPECT_TRUE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://127.0.0.1")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file:///foo/bar")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("file://localhost/foo/bar")));
-};
+}
 
 // <all_urls>
 TEST(ExtensionURLPatternTest, Match11) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("<all_urls>"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_TRUE(pattern.MatchesScheme("file"));
   EXPECT_TRUE(pattern.MatchesScheme("filesystem"));
@@ skipping 11 matching lines @@
   URLPattern pattern2(kAllSchemes);
   pattern2.SetMatchAllURLs(true);
 
   EXPECT_EQ(pattern.valid_schemes(), pattern2.valid_schemes());
   EXPECT_EQ(pattern.match_subdomains(), pattern2.match_subdomains());
   EXPECT_EQ(pattern.path(), pattern2.path());
   EXPECT_EQ(pattern.match_all_urls(), pattern2.match_all_urls());
   EXPECT_EQ(pattern.scheme(), pattern2.scheme());
   EXPECT_EQ(pattern.port(), pattern2.port());
   EXPECT_EQ(pattern.GetAsString(), pattern2.GetAsString());
-};
+}
 
 // SCHEME_ALL matches all schemes.
 TEST(ExtensionURLPatternTest, Match12) {
   URLPattern pattern(URLPattern::SCHEME_ALL);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("<all_urls>"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome"));
   EXPECT_TRUE(pattern.MatchesScheme("http"));
   EXPECT_TRUE(pattern.MatchesScheme("https"));
   EXPECT_TRUE(pattern.MatchesScheme("file"));
   EXPECT_TRUE(pattern.MatchesScheme("filesystem"));
   EXPECT_TRUE(pattern.MatchesScheme("javascript"));
   EXPECT_TRUE(pattern.MatchesScheme("data"));
   EXPECT_TRUE(pattern.MatchesScheme("about"));
   EXPECT_TRUE(pattern.MatchesScheme("chrome-extension"));
   EXPECT_TRUE(pattern.match_subdomains());
   EXPECT_TRUE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://favicon/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("http://127.0.0.1")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file:///foo/bar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("file://localhost/foo/bar")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome://newtab")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("about:blank")));
   EXPECT_TRUE(pattern.MatchesURL(GURL("about:version")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("data:text/html;charset=utf-8,<html>asdf</html>")));
-};
+}
 
 static const struct MatchPatterns {
   const char* pattern;
   const char* matches;
 } kMatch13UrlPatternTestCases[] = {
   {"about:*", "about:blank"},
   {"about:blank", "about:blank"},
   {"about:*", "about:version"},
   {"chrome-extension://*/*", "chrome-extension://FTW"},
   {"data:*", "data:monkey"},
   {"javascript:*", "javascript:atemyhomework"},
 };
 
 // SCHEME_ALL and specific schemes.
 TEST(ExtensionURLPatternTest, Match13) {
   for (size_t i = 0; i < arraysize(kMatch13UrlPatternTestCases); ++i) {
     URLPattern pattern(URLPattern::SCHEME_ALL);
     EXPECT_EQ(URLPattern::PARSE_SUCCESS,
               pattern.Parse(kMatch13UrlPatternTestCases[i].pattern))
         << " while parsing " << kMatch13UrlPatternTestCases[i].pattern;
     EXPECT_TRUE(pattern.MatchesURL(
         GURL(kMatch13UrlPatternTestCases[i].matches)))
         << " while matching " << kMatch13UrlPatternTestCases[i].matches;
   }
 
   // Negative test.
   URLPattern pattern(URLPattern::SCHEME_ALL);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("data:*"));
   EXPECT_FALSE(pattern.MatchesURL(GURL("about:blank")));
-};
+}
 
 // file scheme with empty hostname
 TEST(ExtensionURLPatternTest, Match14) {
   URLPattern pattern(kAllSchemes);
   EXPECT_EQ(URLPattern::PARSE_SUCCESS, pattern.Parse("file:///foo*"));
   EXPECT_EQ("file", pattern.scheme());
   EXPECT_EQ("", pattern.host());
   EXPECT_FALSE(pattern.match_subdomains());
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/foo*", pattern.path());
@@ skipping 86 matching lines @@
   EXPECT_FALSE(pattern.match_all_urls());
   EXPECT_EQ("/*", pattern.path());
   EXPECT_TRUE(pattern.MatchesURL(GURL("chrome-extension://ftw")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("chrome-extension://ftw/http://google.com")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("chrome-extension://ftw/https://google.com")));
   EXPECT_FALSE(pattern.MatchesURL(GURL("chrome-extension://foobar")));
   EXPECT_TRUE(pattern.MatchesURL(
       GURL("filesystem:chrome-extension://ftw/t/file.txt")));
-};
+}
 
 static const struct GetAsStringPatterns {
   const char* pattern;
 } kGetAsStringTestCases[] = {
   { "http://www/" },
   { "http://*/*" },
   { "chrome://*/*" },
   { "chrome://newtab/" },
   { "about:*" },
   { "about:blank" },
@@ skipping 391 matching lines @@
   EXPECT_TRUE(URLPattern(URLPattern::SCHEME_HTTPS, "https://www.google.com/")
                   .MatchesSingleOrigin());
   EXPECT_FALSE(URLPattern(URLPattern::SCHEME_HTTP,
                           "http://*.google.com/foo/bar").MatchesSingleOrigin());
   EXPECT_TRUE(
       URLPattern(URLPattern::SCHEME_HTTP, "http://www.google.com/foo/bar")
           .MatchesSingleOrigin());
 }
 
 }  // namespace