Rename WebCore namespace to blink in Platform

Source/platform/weborigin/KURLTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 59 matching lines @@
     } cases[] = {
         {"http://www.google.com/foo/blah?bar=baz#ref", "http", "www.google.com", 0, "", 0, "blah", "bar=baz", "ref", true},
         {"http://foo.com:1234/foo/bar/", "http", "foo.com", 1234, "", 0, "bar", 0, 0, false},
         {"http://www.google.com?#", "http", "www.google.com", 0, "", 0, 0, "", "", true},
         {"https://me:pass@google.com:23#foo", "https", "google.com", 23, "me", "pass", 0, 0, "foo", true},
         {"javascript:hello!//world", "javascript", "", 0, "", 0, "world", 0, 0, false},
     };
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
         // UTF-8
-        WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url);
+        blink::KURL kurl(blink::ParsedURLString, cases[i].url);
 
         EXPECT_EQ(cases[i].protocol, kurl.protocol());
         EXPECT_EQ(cases[i].host, kurl.host());
         EXPECT_EQ(cases[i].port, kurl.port());
         EXPECT_EQ(cases[i].user, kurl.user());
         EXPECT_EQ(cases[i].pass, kurl.pass());
         EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent());
         EXPECT_EQ(cases[i].query, kurl.query());
         EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier());
         EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier());
 
         // UTF-16
         WTF::String utf16(cases[i].url);
-        kurl = WebCore::KURL(WebCore::ParsedURLString, utf16);
+        kurl = blink::KURL(blink::ParsedURLString, utf16);
 
         EXPECT_EQ(cases[i].protocol, kurl.protocol());
         EXPECT_EQ(cases[i].host, kurl.host());
         EXPECT_EQ(cases[i].port, kurl.port());
         EXPECT_EQ(cases[i].user, kurl.user());
         EXPECT_EQ(cases[i].pass, kurl.pass());
         EXPECT_EQ(cases[i].lastPathComponent, kurl.lastPathComponent());
         EXPECT_EQ(cases[i].query, kurl.query());
         EXPECT_EQ(cases[i].ref, kurl.fragmentIdentifier());
         EXPECT_EQ(cases[i].hasRef, kurl.hasFragmentIdentifier());
@@ skipping 16 matching lines @@
         {"http://a.com/hello;world",              "http",       "a.com",    0,    "",   0,               "hello",  0,         0},
 
         // WebKit doesn't like UTF-8 or UTF-16 input.
         {"http://\xe4\xbd\xa0\xe5\xa5\xbd\xe4\xbd\xa0\xe5\xa5\xbd/", "http", "xn--6qqa088eba", 0, "", 0, 0,        0,         0},
 
         // WebKit %-escapes non-ASCII characters in reference, but we don't.
         {"http://www.google.com/foo/blah?bar=baz#\xce\xb1\xce\xb2", "http", "www.google.com", 0, "", 0,  "blah", "bar=baz", "\xce\xb1\xce\xb2"},
     };
 
     for (size_t i = 0; i < arraysize(cases); i++) {
-        WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url);
+        blink::KURL kurl(blink::ParsedURLString, cases[i].url);
 
         EXPECT_EQ(cases[i].protocol, kurl.protocol());
         EXPECT_EQ(cases[i].host, kurl.host());
         EXPECT_EQ(cases[i].port, kurl.port());
         EXPECT_EQ(cases[i].user, kurl.user());
         EXPECT_EQ(cases[i].pass, kurl.pass());
         EXPECT_EQ(cases[i].lastPath, kurl.lastPathComponent());
         EXPECT_EQ(cases[i].query, kurl.query());
         // Want to compare UCS-16 refs (or to null).
         if (cases[i].ref)
             EXPECT_EQ(WTF::String::fromUTF8(cases[i].ref), kurl.fragmentIdentifier());
         else
             EXPECT_TRUE(kurl.fragmentIdentifier().isNull());
     }
 }
 
 // Ensures that both ASCII and UTF-8 canonical URLs are handled properly and we
 // get the correct string object out.
 TEST(KURLTest, DISABLED_UTF8)
 {
     const char asciiURL[] = "http://foo/bar#baz";
-    WebCore::KURL asciiKURL(WebCore::ParsedURLString, asciiURL);
+    blink::KURL asciiKURL(blink::ParsedURLString, asciiURL);
     EXPECT_TRUE(asciiKURL.string() == WTF::String(asciiURL));
 
     // When the result is ASCII, we should get an ASCII String. Some
     // code depends on being able to compare the result of the .string()
     // getter with another String, and the isASCIIness of the two
     // strings must match for these functions (like equalIgnoringCase).
     EXPECT_TRUE(WTF::equalIgnoringCase(asciiKURL, WTF::String(asciiURL)));
 
     // Reproduce code path in FrameLoader.cpp -- equalIgnoringCase implicitly
     // expects gkurl.protocol() to have been created as ascii.
-    WebCore::KURL mailto(WebCore::ParsedURLString, "mailto:foo@foo.com");
+    blink::KURL mailto(blink::ParsedURLString, "mailto:foo@foo.com");
     EXPECT_TRUE(WTF::equalIgnoringCase(mailto.protocol(), "mailto"));
 
     const char utf8URL[] = "http://foo/bar#\xe4\xbd\xa0\xe5\xa5\xbd";
-    WebCore::KURL utf8KURL(WebCore::ParsedURLString, utf8URL);
+    blink::KURL utf8KURL(blink::ParsedURLString, utf8URL);
 
     EXPECT_TRUE(utf8KURL.string() == WTF::String::fromUTF8(utf8URL));
 }
 
 TEST(KURLTest, Setters)
 {
     // Replace the starting URL with the given components one at a time and
     // verify that we're always the same as the old KURL.
     //
     // Note that old KURL won't canonicalize the default port away, so we
@@ skipping 53 matching lines @@
             // pass
             "", "http://goo.com:92/a?f#b",
             // path
             "/", "http://goo.com:92/?f#b",
             // query
             0, "http://goo.com:92/#b"
         },
     };
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(cases); i++) {
-        WebCore::KURL kurl(WebCore::ParsedURLString, cases[i].url);
+        blink::KURL kurl(blink::ParsedURLString, cases[i].url);
 
         kurl.setProtocol(cases[i].protocol);
         EXPECT_STREQ(cases[i].expectedProtocol, kurl.string().utf8().data());
 
         kurl.setHost(cases[i].host);
         EXPECT_STREQ(cases[i].expectedHost, kurl.string().utf8().data());
 
         kurl.setPort(cases[i].port);
         EXPECT_STREQ(cases[i].expectedPort, kurl.string().utf8().data());
 
@@ skipping 29 matching lines @@
         {"%40%41%42%43%44%45%46%47%48%49%4a%4B%4C%4D%4e%4f/", "@ABCDEFGHIJKLMNO/"},
         {"%50%51%52%53%54%55%56%57%58%59%5a%5B%5C%5D%5e%5f/", "PQRSTUVWXYZ[\\]^_/"},
         {"%60%61%62%63%64%65%66%67%68%69%6a%6B%6C%6D%6e%6f/", "`abcdefghijklmno/"},
         {"%70%71%72%73%74%75%76%77%78%79%7a%7B%7C%7D%7e%7f/", "pqrstuvwxyz{|}~\x7f/"},
           // Test un-UTF-8-ization.
         {"%e4%bd%a0%e5%a5%bd", "\xe4\xbd\xa0\xe5\xa5\xbd"},
     };
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(decodeCases); i++) {
         WTF::String input(decodeCases[i].input);
-        WTF::String str = WebCore::decodeURLEscapeSequences(input);
+        WTF::String str = blink::decodeURLEscapeSequences(input);
         EXPECT_STREQ(decodeCases[i].output, str.utf8().data());
     }
 
     // Our decode should decode %00
-    WTF::String zero = WebCore::decodeURLEscapeSequences("%00");
+    WTF::String zero = blink::decodeURLEscapeSequences("%00");
     EXPECT_STRNE("%00", zero.utf8().data());
 
     // Test the error behavior for invalid UTF-8 (we differ from WebKit here).
-    WTF::String invalid = WebCore::decodeURLEscapeSequences(
+    WTF::String invalid = blink::decodeURLEscapeSequences(
         "%e4%a0%e5%a5%bd");
     UChar invalidExpectedHelper[4] = { 0x00e4, 0x00a0, 0x597d, 0 };
     WTF::String invalidExpected(
         reinterpret_cast<const ::UChar*>(invalidExpectedHelper),
         3);
     EXPECT_EQ(invalidExpected, invalid);
 }
 
 TEST(KURLTest, Encode)
 {
@@ skipping 15 matching lines @@
           "PQRSTUVWXYZ%5B%5C%5D%5E_"},
         {"`abcdefghijklmno",
           "%60abcdefghijklmno"},
         {"pqrstuvwxyz{|}~\x7f",
           "pqrstuvwxyz%7B%7C%7D~%7F"},
     };
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(encode_cases); i++) {
         WTF::String input(encode_cases[i].input);
         WTF::String expectedOutput(encode_cases[i].output);
-        WTF::String output = WebCore::encodeWithURLEscapeSequences(input);
+        WTF::String output = blink::encodeWithURLEscapeSequences(input);
         EXPECT_EQ(expectedOutput, output);
     }
 
     // Our encode escapes NULLs for safety, so we need to check that too.
     WTF::String input("\x00\x01", 2);
     WTF::String reference("%00%01");
 
-    WTF::String output = WebCore::encodeWithURLEscapeSequences(input);
+    WTF::String output = blink::encodeWithURLEscapeSequences(input);
     EXPECT_EQ(reference, output);
 
     // Also test that it gets converted to UTF-8 properly.
     UChar wideInputHelper[3] = { 0x4f60, 0x597d, 0 };
     WTF::String wideInput(
         reinterpret_cast<const ::UChar*>(wideInputHelper), 2);
     WTF::String wideReference("%E4%BD%A0%E5%A5%BD");
     WTF::String wideOutput =
-        WebCore::encodeWithURLEscapeSequences(wideInput);
+        blink::encodeWithURLEscapeSequences(wideInput);
     EXPECT_EQ(wideReference, wideOutput);
 }
 
 TEST(KURLTest, ResolveEmpty)
 {
-    WebCore::KURL emptyBase;
+    blink::KURL emptyBase;
 
     // WebKit likes to be able to resolve absolute input agains empty base URLs,
     // which would normally be invalid since the base URL is invalid.
     const char abs[] = "http://www.google.com/";
-    WebCore::KURL resolveAbs(emptyBase, abs);
+    blink::KURL resolveAbs(emptyBase, abs);
     EXPECT_TRUE(resolveAbs.isValid());
     EXPECT_STREQ(abs, resolveAbs.string().utf8().data());
 
     // Resolving a non-relative URL agains the empty one should still error.
     const char rel[] = "foo.html";
-    WebCore::KURL resolveErr(emptyBase, rel);
+    blink::KURL resolveErr(emptyBase, rel);
     EXPECT_FALSE(resolveErr.isValid());
 }
 
 // WebKit will make empty URLs and set components on them. kurl doesn't allow
 // replacements on invalid URLs, but here we do.
 TEST(KURLTest, ReplaceInvalid)
 {
-    WebCore::KURL kurl;
+    blink::KURL kurl;
 
     EXPECT_FALSE(kurl.isValid());
     EXPECT_TRUE(kurl.isEmpty());
     EXPECT_STREQ("", kurl.string().utf8().data());
 
     kurl.setProtocol("http");
     // GKURL will say that a URL with just a scheme is invalid, KURL will not.
     EXPECT_FALSE(kurl.isValid());
     EXPECT_FALSE(kurl.isEmpty());
     // At this point, we do things slightly differently if there is only a scheme.
@@ skipping 18 matching lines @@
 
     // Now let's test that giving an invalid replacement fails. Invalid
     // protocols fail without modifying the URL, which should remain valid.
     EXPECT_FALSE(kurl.setProtocol("f/sj#@"));
     EXPECT_TRUE(kurl.isValid());
 }
 
 TEST(KURLTest, Path)
 {
     const char initial[] = "http://www.google.com/path/foo";
-    WebCore::KURL kurl(WebCore::ParsedURLString, initial);
+    blink::KURL kurl(blink::ParsedURLString, initial);
 
     // Clear by setting a null string.
     WTF::String nullString;
     EXPECT_TRUE(nullString.isNull());
     kurl.setPath(nullString);
     EXPECT_STREQ("http://www.google.com/", kurl.string().utf8().data());
 }
 
 // Test that setting the query to different things works. Thq query is handled
 // a littler differently than some of the other components.
 TEST(KURLTest, Query)
 {
     const char initial[] = "http://www.google.com/search?q=awesome";
-    WebCore::KURL kurl(WebCore::ParsedURLString, initial);
+    blink::KURL kurl(blink::ParsedURLString, initial);
 
     // Clear by setting a null string.
     WTF::String nullString;
     EXPECT_TRUE(nullString.isNull());
     kurl.setQuery(nullString);
     EXPECT_STREQ("http://www.google.com/search", kurl.string().utf8().data());
 
     // Clear by setting an empty string.
-    kurl = WebCore::KURL(WebCore::ParsedURLString, initial);
+    kurl = blink::KURL(blink::ParsedURLString, initial);
     WTF::String emptyString("");
     EXPECT_FALSE(emptyString.isNull());
     kurl.setQuery(emptyString);
     EXPECT_STREQ("http://www.google.com/search?", kurl.string().utf8().data());
 
     // Set with something that begins in a question mark.
     const char question[] = "?foo=bar";
     kurl.setQuery(question);
     EXPECT_STREQ("http://www.google.com/search?foo=bar",
                  kurl.string().utf8().data());
 
     // Set with something that doesn't begin in a question mark.
     const char query[] = "foo=bar";
     kurl.setQuery(query);
     EXPECT_STREQ("http://www.google.com/search?foo=bar",
                  kurl.string().utf8().data());
 }
 
 TEST(KURLTest, Ref)
 {
-    WebCore::KURL kurl(WebCore::ParsedURLString, "http://foo/bar#baz");
+    blink::KURL kurl(blink::ParsedURLString, "http://foo/bar#baz");
 
     // Basic ref setting.
-    WebCore::KURL cur(WebCore::ParsedURLString, "http://foo/bar");
+    blink::KURL cur(blink::ParsedURLString, "http://foo/bar");
     cur.setFragmentIdentifier("asdf");
     EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data());
     cur = kurl;
     cur.setFragmentIdentifier("asdf");
     EXPECT_STREQ("http://foo/bar#asdf", cur.string().utf8().data());
 
     // Setting a ref to the empty string will set it to "#".
-    cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar");
+    cur = blink::KURL(blink::ParsedURLString, "http://foo/bar");
     cur.setFragmentIdentifier("");
     EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data());
     cur = kurl;
     cur.setFragmentIdentifier("");
     EXPECT_STREQ("http://foo/bar#", cur.string().utf8().data());
 
     // Setting the ref to the null string will clear it altogether.
-    cur = WebCore::KURL(WebCore::ParsedURLString, "http://foo/bar");
+    cur = blink::KURL(blink::ParsedURLString, "http://foo/bar");
     cur.setFragmentIdentifier(WTF::String());
     EXPECT_STREQ("http://foo/bar", cur.string().utf8().data());
     cur = kurl;
     cur.setFragmentIdentifier(WTF::String());
     EXPECT_STREQ("http://foo/bar", cur.string().utf8().data());
 }
 
 TEST(KURLTest, Empty)
 {
-    WebCore::KURL kurl;
+    blink::KURL kurl;
 
     // First test that regular empty URLs are the same.
     EXPECT_TRUE(kurl.isEmpty());
     EXPECT_FALSE(kurl.isValid());
     EXPECT_TRUE(kurl.isNull());
     EXPECT_TRUE(kurl.string().isNull());
     EXPECT_TRUE(kurl.string().isEmpty());
 
     // Test resolving a null URL on an empty string.
-    WebCore::KURL kurl2(kurl, "");
+    blink::KURL kurl2(kurl, "");
     EXPECT_TRUE(kurl2.isNull());
     EXPECT_TRUE(kurl2.isEmpty());
     EXPECT_FALSE(kurl2.isValid());
     EXPECT_TRUE(kurl2.string().isNull());
     EXPECT_TRUE(kurl2.string().isEmpty());
     EXPECT_TRUE(kurl2.string().isNull());
     EXPECT_TRUE(kurl2.string().isEmpty());
 
     // Resolve the null URL on a null string.
-    WebCore::KURL kurl22(kurl, WTF::String());
+    blink::KURL kurl22(kurl, WTF::String());
     EXPECT_TRUE(kurl22.isNull());
     EXPECT_TRUE(kurl22.isEmpty());
     EXPECT_FALSE(kurl22.isValid());
     EXPECT_TRUE(kurl22.string().isNull());
     EXPECT_TRUE(kurl22.string().isEmpty());
     EXPECT_TRUE(kurl22.string().isNull());
     EXPECT_TRUE(kurl22.string().isEmpty());
 
     // Test non-hierarchical schemes resolving. The actual URLs will be different.
     // WebKit's one will set the string to "something.gif" and we'll set it to an
     // empty string. I think either is OK, so we just check our behavior.
-    WebCore::KURL kurl3(WebCore::KURL(WebCore::ParsedURLString, "data:foo"),
+    blink::KURL kurl3(blink::KURL(blink::ParsedURLString, "data:foo"),
                         "something.gif");
     EXPECT_TRUE(kurl3.isEmpty());
     EXPECT_FALSE(kurl3.isValid());
 
     // Test for weird isNull string input,
     // see: http://bugs.webkit.org/show_bug.cgi?id=16487
-    WebCore::KURL kurl4(WebCore::ParsedURLString, kurl.string());
+    blink::KURL kurl4(blink::ParsedURLString, kurl.string());
     EXPECT_TRUE(kurl4.isEmpty());
     EXPECT_FALSE(kurl4.isValid());
     EXPECT_TRUE(kurl4.string().isNull());
     EXPECT_TRUE(kurl4.string().isEmpty());
 
     // Resolving an empty URL on an invalid string.
-    WebCore::KURL kurl5(WebCore::KURL(), "foo.js");
+    blink::KURL kurl5(blink::KURL(), "foo.js");
     // We'll be empty in this case, but KURL won't be. Should be OK.
     // EXPECT_EQ(kurl5.isEmpty(), kurl5.isEmpty());
     // EXPECT_EQ(kurl5.string().isEmpty(), kurl5.string().isEmpty());
     EXPECT_FALSE(kurl5.isValid());
     EXPECT_TRUE(kurl5.string().isNull());
 
     // Empty string as input
-    WebCore::KURL kurl6(WebCore::ParsedURLString, "");
+    blink::KURL kurl6(blink::ParsedURLString, "");
     EXPECT_TRUE(kurl6.isEmpty());
     EXPECT_FALSE(kurl6.isValid());
     EXPECT_TRUE(kurl6.string().isNull());
     EXPECT_TRUE(kurl6.string().isEmpty());
 
     // Non-empty but invalid C string as input.
-    WebCore::KURL kurl7(WebCore::ParsedURLString, "foo.js");
+    blink::KURL kurl7(blink::ParsedURLString, "foo.js");
     // WebKit will actually say this URL has the string "foo.js" but is invalid.
     // We don't do that.
     // EXPECT_EQ(kurl7.isEmpty(), kurl7.isEmpty());
     EXPECT_FALSE(kurl7.isValid());
     EXPECT_TRUE(kurl7.string().isNull());
 }
 
 TEST(KURLTest, UserPass)
 {
     const char* src = "http://user:pass@google.com/";
-    WebCore::KURL kurl(WebCore::ParsedURLString, src);
+    blink::KURL kurl(blink::ParsedURLString, src);
 
     // Clear just the username.
     kurl.setUser("");
     EXPECT_EQ("http://:pass@google.com/", kurl.string());
 
     // Clear just the password.
-    kurl = WebCore::KURL(WebCore::ParsedURLString, src);
+    kurl = blink::KURL(blink::ParsedURLString, src);
     kurl.setPass("");
     EXPECT_EQ("http://user@google.com/", kurl.string());
 
     // Now clear both.
     kurl.setUser("");
     EXPECT_EQ("http://google.com/", kurl.string());
 }
 
 TEST(KURLTest, Offsets)
 {
     const char* src1 = "http://user:pass@google.com/foo/bar.html?baz=query#ref";
-    WebCore::KURL kurl1(WebCore::ParsedURLString, src1);
+    blink::KURL kurl1(blink::ParsedURLString, src1);
 
     EXPECT_EQ(17u, kurl1.hostStart());
     EXPECT_EQ(27u, kurl1.hostEnd());
     EXPECT_EQ(27u, kurl1.pathStart());
     EXPECT_EQ(40u, kurl1.pathEnd());
     EXPECT_EQ(32u, kurl1.pathAfterLastSlash());
 
     const char* src2 = "http://google.com/foo/";
-    WebCore::KURL kurl2(WebCore::ParsedURLString, src2);
+    blink::KURL kurl2(blink::ParsedURLString, src2);
 
     EXPECT_EQ(7u, kurl2.hostStart());
     EXPECT_EQ(17u, kurl2.hostEnd());
     EXPECT_EQ(17u, kurl2.pathStart());
     EXPECT_EQ(22u, kurl2.pathEnd());
     EXPECT_EQ(22u, kurl2.pathAfterLastSlash());
 
     const char* src3 = "javascript:foobar";
-    WebCore::KURL kurl3(WebCore::ParsedURLString, src3);
+    blink::KURL kurl3(blink::ParsedURLString, src3);
 
     EXPECT_EQ(11u, kurl3.hostStart());
     EXPECT_EQ(11u, kurl3.hostEnd());
     EXPECT_EQ(11u, kurl3.pathStart());
     EXPECT_EQ(17u, kurl3.pathEnd());
     EXPECT_EQ(11u, kurl3.pathAfterLastSlash());
 }
 
 TEST(KURLTest, DeepCopy)
 {
     const char url[] = "http://www.google.com/";
-    WebCore::KURL src(WebCore::ParsedURLString, url);
+    blink::KURL src(blink::ParsedURLString, url);
     EXPECT_TRUE(src.string() == url); // This really just initializes the cache.
-    WebCore::KURL dest = src.copy();
+    blink::KURL dest = src.copy();
     EXPECT_TRUE(dest.string() == url); // This really just initializes the cache.
 
     // The pointers should be different for both UTF-8 and UTF-16.
     EXPECT_NE(dest.string().impl(), src.string().impl());
 }
 
 TEST(KURLTest, DeepCopyInnerURL)
 {
     const char url[] = "filesystem:http://www.google.com/temporary/test.txt";
     const char innerURL[] = "http://www.google.com/temporary";
-    WebCore::KURL src(WebCore::ParsedURLString, url);
+    blink::KURL src(blink::ParsedURLString, url);
     EXPECT_TRUE(src.string() == url);
     EXPECT_TRUE(src.innerURL()->string() == innerURL);
-    WebCore::KURL dest = src.copy();
+    blink::KURL dest = src.copy();
     EXPECT_TRUE(dest.string() == url);
     EXPECT_TRUE(dest.innerURL()->string() == innerURL);
 }
 
 TEST(KURLTest, LastPathComponent)
 {
-    WebCore::KURL url1(WebCore::ParsedURLString, "http://host/path/to/file.txt");
+    blink::KURL url1(blink::ParsedURLString, "http://host/path/to/file.txt");
     EXPECT_EQ("file.txt", url1.lastPathComponent());
 
-    WebCore::KURL invalidUTF8(WebCore::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
+    blink::KURL invalidUTF8(blink::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
     EXPECT_EQ(String(), invalidUTF8.lastPathComponent());
 }
 
 TEST(KURLTest, IsHierarchical)
 {
-    WebCore::KURL url1(WebCore::ParsedURLString, "http://host/path/to/file.txt");
+    blink::KURL url1(blink::ParsedURLString, "http://host/path/to/file.txt");
     EXPECT_TRUE(url1.isHierarchical());
 
-    WebCore::KURL invalidUTF8(WebCore::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
+    blink::KURL invalidUTF8(blink::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
     EXPECT_FALSE(invalidUTF8.isHierarchical());
 }
 
 TEST(KURLTest, PathAfterLastSlash)
 {
-    WebCore::KURL url1(WebCore::ParsedURLString, "http://host/path/to/file.txt");
+    blink::KURL url1(blink::ParsedURLString, "http://host/path/to/file.txt");
     EXPECT_EQ(20u, url1.pathAfterLastSlash());
 
-    WebCore::KURL invalidUTF8(WebCore::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
+    blink::KURL invalidUTF8(blink::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
     EXPECT_EQ(0u, invalidUTF8.pathAfterLastSlash());
 }
 
 TEST(KURLTest, ProtocolIsInHTTPFamily)
 {
-    WebCore::KURL url1(WebCore::ParsedURLString, "http://host/path/to/file.txt");
+    blink::KURL url1(blink::ParsedURLString, "http://host/path/to/file.txt");
     EXPECT_TRUE(url1.protocolIsInHTTPFamily());
 
-    WebCore::KURL invalidUTF8(WebCore::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
+    blink::KURL invalidUTF8(blink::ParsedURLString, "http://a@9%aa%:/path/to/file.txt");
     EXPECT_FALSE(invalidUTF8.protocolIsInHTTPFamily());
 }
 
 TEST(KURLTest, ProtocolIs)
 {
-    WebCore::KURL url1(WebCore::ParsedURLString, "foo://bar");
+    blink::KURL url1(blink::ParsedURLString, "foo://bar");
     EXPECT_TRUE(url1.protocolIs("foo"));
     EXPECT_FALSE(url1.protocolIs("foo-bar"));
 
-    WebCore::KURL url2(WebCore::ParsedURLString, "foo-bar:");
+    blink::KURL url2(blink::ParsedURLString, "foo-bar:");
     EXPECT_TRUE(url2.protocolIs("foo-bar"));
     EXPECT_FALSE(url2.protocolIs("foo"));
 
-    WebCore::KURL invalidUTF8(WebCore::ParsedURLString, "http://a@9%aa%:");
+    blink::KURL invalidUTF8(blink::ParsedURLString, "http://a@9%aa%:");
     EXPECT_FALSE(invalidUTF8.protocolIs("http"));
     EXPECT_TRUE(invalidUTF8.protocolIs(""));
 }
 
 TEST(KURLTest, strippedForUseAsReferrer)
 {
     struct ReferrerCase {
         const char* input;
         const char* output;
     } referrerCases[] = {
         {"data:text/html;charset=utf-8,<html></html>", ""},
         {"javascript:void(0);", ""},
         {"about:config", ""},
         {"https://www.google.com/", "https://www.google.com/"},
         {"http://me@news.google.com:8888/", "http://news.google.com:8888/"},
         {"http://:pass@news.google.com:8888/foo", "http://news.google.com:8888/foo"},
         {"http://me:pass@news.google.com:8888/", "http://news.google.com:8888/"},
         {"https://www.google.com/a?f#b", "https://www.google.com/a?f"},
     };
 
     for (size_t i = 0; i < ARRAYSIZE_UNSAFE(referrerCases); i++) {
-        WebCore::KURL kurl(WebCore::ParsedURLString, referrerCases[i].input);
+        blink::KURL kurl(blink::ParsedURLString, referrerCases[i].input);
         WTF::String referrer = kurl.strippedForUseAsReferrer();
         EXPECT_STREQ(referrerCases[i].output, referrer.utf8().data());
     }
 }
 
 } // namespace