diff options
Diffstat (limited to 'net')
75 files changed, 719 insertions, 463 deletions
diff --git a/net/base/dns_util.cc b/net/base/dns_util.cc index 816095b..b94eff8 100644 --- a/net/base/dns_util.cc +++ b/net/base/dns_util.cc @@ -62,16 +62,16 @@ std::string DNSDomainToString(const base::StringPiece& domain) { for (unsigned i = 0; i < domain.size() && domain[i]; i += domain[i] + 1) { #if CHAR_MIN < 0 if (domain[i] < 0) - return ""; + return std::string(); #endif if (domain[i] > 63) - return ""; + return std::string(); if (i) ret += "."; if (static_cast<unsigned>(domain[i]) + i + 1 > domain.size()) - return ""; + return std::string(); domain.substr(i + 1, domain[i]).AppendToString(&ret); } diff --git a/net/base/host_mapping_rules_unittest.cc b/net/base/host_mapping_rules_unittest.cc index 9ecd4b7..8d8f7b1 100644 --- a/net/base/host_mapping_rules_unittest.cc +++ b/net/base/host_mapping_rules_unittest.cc @@ -72,7 +72,7 @@ TEST(HostMappingRulesTest, ParseInvalidRules) { HostMappingRules rules; EXPECT_FALSE(rules.AddRuleFromString("xyz")); - EXPECT_FALSE(rules.AddRuleFromString("")); + EXPECT_FALSE(rules.AddRuleFromString(std::string())); EXPECT_FALSE(rules.AddRuleFromString(" ")); EXPECT_FALSE(rules.AddRuleFromString("EXCLUDE")); EXPECT_FALSE(rules.AddRuleFromString("EXCLUDE foo bar")); diff --git a/net/base/mime_sniffer_unittest.cc b/net/base/mime_sniffer_unittest.cc index a4bde0f..7865350 100644 --- a/net/base/mime_sniffer_unittest.cc +++ b/net/base/mime_sniffer_unittest.cc @@ -304,13 +304,14 @@ TEST(MimeSnifferTest, FlashTest) { TEST(MimeSnifferTest, XMLTest) { // An easy feed to identify. EXPECT_EQ("application/atom+xml", - SniffMimeType("<?xml?><feed", "", "text/xml")); + SniffMimeType("<?xml?><feed", std::string(), "text/xml")); // Don't sniff out of plain text. EXPECT_EQ("text/plain", - SniffMimeType("<?xml?><feed", "", "text/plain")); + SniffMimeType("<?xml?><feed", std::string(), "text/plain")); // Simple RSS. EXPECT_EQ("application/rss+xml", - SniffMimeType("<?xml version='1.0'?>\r\n<rss", "", "text/xml")); + SniffMimeType( + "<?xml version='1.0'?>\r\n<rss", std::string(), "text/xml")); // The top of CNN's RSS feed, which we'd like to recognize as RSS. static const char kCNNRSS[] = @@ -323,39 +324,43 @@ TEST(MimeSnifferTest, XMLTest) { "version=\"2.0\">"; // CNN's RSS EXPECT_EQ("application/rss+xml", - SniffMimeType(kCNNRSS, "", "text/xml")); - EXPECT_EQ("text/plain", - SniffMimeType(kCNNRSS, "", "text/plain")); + SniffMimeType(kCNNRSS, std::string(), "text/xml")); + EXPECT_EQ("text/plain", SniffMimeType(kCNNRSS, std::string(), "text/plain")); // Don't sniff random XML as something different. EXPECT_EQ("text/xml", - SniffMimeType("<?xml?><notafeed", "", "text/xml")); + SniffMimeType("<?xml?><notafeed", std::string(), "text/xml")); // Don't sniff random plain-text as something different. EXPECT_EQ("text/plain", - SniffMimeType("<?xml?><notafeed", "", "text/plain")); + SniffMimeType("<?xml?><notafeed", std::string(), "text/plain")); // Positive test for the two instances we upgrade to XHTML. EXPECT_EQ("application/xhtml+xml", SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", - "", "text/xml")); + std::string(), + "text/xml")); EXPECT_EQ("application/xhtml+xml", SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", - "", "application/xml")); + std::string(), + "application/xml")); // Following our behavior with HTML, don't call other mime types XHTML. EXPECT_EQ("text/plain", SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", - "", "text/plain")); + std::string(), + "text/plain")); EXPECT_EQ("application/rss+xml", SniffMimeType("<html xmlns=\"http://www.w3.org/1999/xhtml\">", - "", "application/rss+xml")); + std::string(), + "application/rss+xml")); // Don't sniff other HTML-looking bits as HTML. EXPECT_EQ("text/xml", - SniffMimeType("<html><head>", "", "text/xml")); + SniffMimeType("<html><head>", std::string(), "text/xml")); EXPECT_EQ("text/xml", SniffMimeType("<foo><html xmlns=\"http://www.w3.org/1999/xhtml\">", - "", "text/xml")); + std::string(), + "text/xml")); } diff --git a/net/base/mime_util.cc b/net/base/mime_util.cc index 21a05bf..b3053a6 100644 --- a/net/base/mime_util.cc +++ b/net/base/mime_util.cc @@ -967,7 +967,7 @@ const std::string GetIANAMediaType(const std::string& mime_type) { return kIanaMediaTypes[i].name; } } - return ""; + return std::string(); } CertificateMimeType GetCertificateMimeTypeForMimeType( diff --git a/net/base/mime_util_unittest.cc b/net/base/mime_util_unittest.cc index ee6663b..565f9de 100644 --- a/net/base/mime_util_unittest.cc +++ b/net/base/mime_util_unittest.cc @@ -93,11 +93,11 @@ TEST(MimeUtilTest, MatchesMimeType) { "application/html+xml")); EXPECT_TRUE(MatchesMimeType("application/*+xml", "application/+xml")); EXPECT_TRUE(MatchesMimeType("aaa*aaa", "aaaaaa")); - EXPECT_TRUE(MatchesMimeType("*", "")); + EXPECT_TRUE(MatchesMimeType("*", std::string())); EXPECT_FALSE(MatchesMimeType("video/", "video/x-mpeg")); - EXPECT_FALSE(MatchesMimeType("", "video/x-mpeg")); - EXPECT_FALSE(MatchesMimeType("", "")); - EXPECT_FALSE(MatchesMimeType("video/x-mpeg", "")); + EXPECT_FALSE(MatchesMimeType(std::string(), "video/x-mpeg")); + EXPECT_FALSE(MatchesMimeType(std::string(), std::string())); + EXPECT_FALSE(MatchesMimeType("video/x-mpeg", std::string())); EXPECT_FALSE(MatchesMimeType("application/*+xml", "application/xml")); EXPECT_FALSE(MatchesMimeType("application/*+xml", "application/html+xmlz")); @@ -219,7 +219,7 @@ TEST(MimeUtilTest, TestIsMimeType) { TEST(MimeUtilTest, TestToIANAMediaType) { EXPECT_EQ("", GetIANAMediaType("texting/driving")); EXPECT_EQ("", GetIANAMediaType("ham/sandwich")); - EXPECT_EQ("", GetIANAMediaType("")); + EXPECT_EQ("", GetIANAMediaType(std::string())); EXPECT_EQ("", GetIANAMediaType("/application/hamsandwich")); EXPECT_EQ("application", GetIANAMediaType("application/poodle-wrestler")); diff --git a/net/base/net_util.cc b/net/base/net_util.cc index 066812c..18d00fe 100644 --- a/net/base/net_util.cc +++ b/net/base/net_util.cc @@ -1433,7 +1433,7 @@ std::string NetAddressToString(const struct sockaddr* sa, if (!GetIPAddressFromSockAddr(sa, sock_addr_len, &address, &address_len, NULL)) { NOTREACHED(); - return ""; + return std::string(); } return IPAddressToString(address, address_len); } @@ -1446,7 +1446,7 @@ std::string NetAddressToStringWithPort(const struct sockaddr* sa, if (!GetIPAddressFromSockAddr(sa, sock_addr_len, &address, &address_len, &port)) { NOTREACHED(); - return ""; + return std::string(); } return IPAddressToStringWithPort(address, address_len, port); } diff --git a/net/base/net_util_unittest.cc b/net/base/net_util_unittest.cc index 8512d09..ab8a236 100644 --- a/net/base/net_util_unittest.cc +++ b/net/base/net_util_unittest.cc @@ -2596,10 +2596,14 @@ TEST(NetUtilTest, FormatUrlParsed) { formatted.substr(parsed.ref.begin, parsed.ref.len)); // View-source case. - formatted = FormatUrl( - GURL("view-source:http://user:passwd@host:81/path?query#ref"), - "", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, &parsed, - NULL, NULL); + formatted = + FormatUrl(GURL("view-source:http://user:passwd@host:81/path?query#ref"), + std::string(), + kFormatUrlOmitUsernamePassword, + UnescapeRule::NORMAL, + &parsed, + NULL, + NULL); EXPECT_EQ(WideToUTF16(L"view-source:http://host:81/path?query#ref"), formatted); EXPECT_EQ(WideToUTF16(L"view-source:http"), @@ -2618,9 +2622,13 @@ TEST(NetUtilTest, FormatUrlParsed) { formatted.substr(parsed.ref.begin, parsed.ref.len)); // omit http case. - formatted = FormatUrl( - GURL("http://host:8000/a?b=c#d"), - "", kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL); + formatted = FormatUrl(GURL("http://host:8000/a?b=c#d"), + std::string(), + kFormatUrlOmitHTTP, + UnescapeRule::NORMAL, + &parsed, + NULL, + NULL); EXPECT_EQ(WideToUTF16(L"host:8000/a?b=c#d"), formatted); EXPECT_FALSE(parsed.scheme.is_valid()); EXPECT_FALSE(parsed.username.is_valid()); @@ -2637,9 +2645,13 @@ TEST(NetUtilTest, FormatUrlParsed) { formatted.substr(parsed.ref.begin, parsed.ref.len)); // omit http starts with ftp case. - formatted = FormatUrl( - GURL("http://ftp.host:8000/a?b=c#d"), - "", kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL); + formatted = FormatUrl(GURL("http://ftp.host:8000/a?b=c#d"), + std::string(), + kFormatUrlOmitHTTP, + UnescapeRule::NORMAL, + &parsed, + NULL, + NULL); EXPECT_EQ(WideToUTF16(L"http://ftp.host:8000/a?b=c#d"), formatted); EXPECT_TRUE(parsed.scheme.is_valid()); EXPECT_FALSE(parsed.username.is_valid()); @@ -2658,9 +2670,13 @@ TEST(NetUtilTest, FormatUrlParsed) { formatted.substr(parsed.ref.begin, parsed.ref.len)); // omit http starts with 'f' case. - formatted = FormatUrl( - GURL("http://f/"), - "", kFormatUrlOmitHTTP, UnescapeRule::NORMAL, &parsed, NULL, NULL); + formatted = FormatUrl(GURL("http://f/"), + std::string(), + kFormatUrlOmitHTTP, + UnescapeRule::NORMAL, + &parsed, + NULL, + NULL); EXPECT_EQ(WideToUTF16(L"f/"), formatted); EXPECT_FALSE(parsed.scheme.is_valid()); EXPECT_FALSE(parsed.username.is_valid()); @@ -2682,9 +2698,13 @@ TEST(NetUtilTest, FormatUrlRoundTripPathASCII) { GURL url(std::string("http://www.google.com/") + static_cast<char>(test_char)); size_t prefix_len; - base::string16 formatted = FormatUrl( - url, "", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, NULL, - &prefix_len, NULL); + base::string16 formatted = FormatUrl(url, + std::string(), + kFormatUrlOmitUsernamePassword, + UnescapeRule::NORMAL, + NULL, + &prefix_len, + NULL); EXPECT_EQ(url.spec(), GURL(formatted).spec()); } } @@ -2699,9 +2719,13 @@ TEST(NetUtilTest, FormatUrlRoundTripPathEscaped) { GURL url(original_url); size_t prefix_len; - base::string16 formatted = FormatUrl( - url, "", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, NULL, - &prefix_len, NULL); + base::string16 formatted = FormatUrl(url, + std::string(), + kFormatUrlOmitUsernamePassword, + UnescapeRule::NORMAL, + NULL, + &prefix_len, + NULL); EXPECT_EQ(url.spec(), GURL(formatted).spec()); } } @@ -2713,9 +2737,13 @@ TEST(NetUtilTest, FormatUrlRoundTripQueryASCII) { GURL url(std::string("http://www.google.com/?") + static_cast<char>(test_char)); size_t prefix_len; - base::string16 formatted = FormatUrl( - url, "", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, NULL, - &prefix_len, NULL); + base::string16 formatted = FormatUrl(url, + std::string(), + kFormatUrlOmitUsernamePassword, + UnescapeRule::NORMAL, + NULL, + &prefix_len, + NULL); EXPECT_EQ(url.spec(), GURL(formatted).spec()); } } @@ -2734,9 +2762,13 @@ TEST(NetUtilTest, FormatUrlRoundTripQueryEscaped) { GURL url(original_url); size_t prefix_len; - base::string16 formatted = FormatUrl( - url, "", kFormatUrlOmitUsernamePassword, UnescapeRule::NORMAL, NULL, - &prefix_len, NULL); + base::string16 formatted = FormatUrl(url, + std::string(), + kFormatUrlOmitUsernamePassword, + UnescapeRule::NORMAL, + NULL, + &prefix_len, + NULL); if (test_char && strchr(kUnescapedCharacters, static_cast<char>(test_char))) { @@ -3036,7 +3068,7 @@ TEST(NetUtilTest, ParseIPLiteralToNumber_FailParse) { EXPECT_FALSE(ParseIPLiteralToNumber("bad value", &number)); EXPECT_FALSE(ParseIPLiteralToNumber("bad:value", &number)); - EXPECT_FALSE(ParseIPLiteralToNumber("", &number)); + EXPECT_FALSE(ParseIPLiteralToNumber(std::string(), &number)); EXPECT_FALSE(ParseIPLiteralToNumber("192.168.0.1:30", &number)); EXPECT_FALSE(ParseIPLiteralToNumber(" 192.168.0.1 ", &number)); EXPECT_FALSE(ParseIPLiteralToNumber("[::1]", &number)); diff --git a/net/base/registry_controlled_domains/registry_controlled_domain_unittest.cc b/net/base/registry_controlled_domains/registry_controlled_domain_unittest.cc index 7ae5da4..8ad8a55 100644 --- a/net/base/registry_controlled_domains/registry_controlled_domain_unittest.cc +++ b/net/base/registry_controlled_domains/registry_controlled_domain_unittest.cc @@ -79,7 +79,7 @@ TEST_F(RegistryControlledDomainTest, TestGetDomainAndRegistry) { EXPECT_EQ("baz.com", GetDomainFromURL("http://baz.com")); // none EXPECT_EQ("baz.com.", GetDomainFromURL("http://baz.com.")); // none - EXPECT_EQ("", GetDomainFromURL("")); + EXPECT_EQ("", GetDomainFromURL(std::string())); EXPECT_EQ("", GetDomainFromURL("http://")); EXPECT_EQ("", GetDomainFromURL("file:///C:/file.html")); EXPECT_EQ("", GetDomainFromURL("http://foo.com..")); @@ -108,7 +108,7 @@ TEST_F(RegistryControlledDomainTest, TestGetDomainAndRegistry) { EXPECT_EQ("baz.com", GetDomainFromHost("baz.com")); // none EXPECT_EQ("baz.com.", GetDomainFromHost("baz.com.")); // none - EXPECT_EQ("", GetDomainFromHost("")); + EXPECT_EQ("", GetDomainFromHost(std::string())); EXPECT_EQ("", GetDomainFromHost("foo.com..")); EXPECT_EQ("", GetDomainFromHost("...")); EXPECT_EQ("", GetDomainFromHost("192.168.0.1")); @@ -143,7 +143,7 @@ TEST_F(RegistryControlledDomainTest, TestGetRegistryLength) { EXPECT_EQ(3U, GetRegistryLengthFromURL("http://baz.com", true)); // none EXPECT_EQ(4U, GetRegistryLengthFromURL("http://baz.com.", true)); // none - EXPECT_EQ(std::string::npos, GetRegistryLengthFromURL("", false)); + EXPECT_EQ(std::string::npos, GetRegistryLengthFromURL(std::string(), false)); EXPECT_EQ(std::string::npos, GetRegistryLengthFromURL("http://", false)); EXPECT_EQ(std::string::npos, GetRegistryLengthFromURL("file:///C:/file.html", false)); @@ -177,7 +177,7 @@ TEST_F(RegistryControlledDomainTest, TestGetRegistryLength) { EXPECT_EQ(3U, GetRegistryLengthFromHost("baz.com", true)); // none EXPECT_EQ(4U, GetRegistryLengthFromHost("baz.com.", true)); // none - EXPECT_EQ(std::string::npos, GetRegistryLengthFromHost("", false)); + EXPECT_EQ(std::string::npos, GetRegistryLengthFromHost(std::string(), false)); EXPECT_EQ(0U, GetRegistryLengthFromHost("foo.com..", false)); EXPECT_EQ(0U, GetRegistryLengthFromHost("..", false)); EXPECT_EQ(0U, GetRegistryLengthFromHost("192.168.0.1", false)); diff --git a/net/base/sdch_filter_unittest.cc b/net/base/sdch_filter_unittest.cc index 2e0f5ec..1cc70cb 100644 --- a/net/base/sdch_filter_unittest.cc +++ b/net/base/sdch_filter_unittest.cc @@ -1346,7 +1346,7 @@ TEST_F(SdchFilterTest, PathMatch) { // Make sure less that sufficient prefix match is false. EXPECT_FALSE(PathMatch("/sear", "/search")); EXPECT_FALSE(PathMatch("/", "/search")); - EXPECT_FALSE(PathMatch("", "/search")); + EXPECT_FALSE(PathMatch(std::string(), "/search")); // Add examples with several levels of direcories in the restriction. EXPECT_FALSE(PathMatch("/search/something", "search/s")); diff --git a/net/cookies/canonical_cookie_unittest.cc b/net/cookies/canonical_cookie_unittest.cc index d7c25d188..161b27f 100644 --- a/net/cookies/canonical_cookie_unittest.cc +++ b/net/cookies/canonical_cookie_unittest.cc @@ -55,8 +55,16 @@ TEST(CanonicalCookieTest, Constructor) { EXPECT_EQ("/test", cookie.Path()); EXPECT_FALSE(cookie.IsSecure()); - CanonicalCookie cookie2(url, "A", "2", "", "", current_time, base::Time(), - current_time, false, false); + CanonicalCookie cookie2(url, + "A", + "2", + std::string(), + std::string(), + current_time, + base::Time(), + current_time, + false, + false); EXPECT_EQ(url.GetOrigin().spec(), cookie.Source()); EXPECT_EQ("A", cookie2.Name()); EXPECT_EQ("2", cookie2.Value()); @@ -287,7 +295,7 @@ TEST(CanonicalCookieTest, IsOnPath) { EXPECT_TRUE(cookie->IsOnPath("/test/bar.html")); // Test the empty string edge case. - EXPECT_FALSE(cookie->IsOnPath("")); + EXPECT_FALSE(cookie->IsOnPath(std::string())); cookie.reset( CanonicalCookie::Create(GURL("http://www.example.com/test/foo.html"), diff --git a/net/cookies/cookie_monster_unittest.cc b/net/cookies/cookie_monster_unittest.cc index 116d486..b3688c3 100644 --- a/net/cookies/cookie_monster_unittest.cc +++ b/net/cookies/cookie_monster_unittest.cc @@ -233,20 +233,44 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> { base::Time(), false, false)); // Host cookies - EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_1, - "host_1", "X", "", "/", - base::Time(), false, false)); - EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, - "host_2", "X", "", "/", - base::Time(), false, false)); - EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_3, - "host_3", "X", "", "/", - base::Time(), false, false)); + EXPECT_TRUE(this->SetCookieWithDetails(cm, + url_top_level_domain_plus_1, + "host_1", + "X", + std::string(), + "/", + base::Time(), + false, + false)); + EXPECT_TRUE(this->SetCookieWithDetails(cm, + url_top_level_domain_plus_2, + "host_2", + "X", + std::string(), + "/", + base::Time(), + false, + false)); + EXPECT_TRUE(this->SetCookieWithDetails(cm, + url_top_level_domain_plus_3, + "host_3", + "X", + std::string(), + "/", + base::Time(), + false, + false)); // Http_only cookie - EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, - "httpo_check", "X", "", "/", - base::Time(), false, true)); + EXPECT_TRUE(this->SetCookieWithDetails(cm, + url_top_level_domain_plus_2, + "httpo_check", + "X", + std::string(), + "/", + base::Time(), + false, + true)); // Secure cookies EXPECT_TRUE(this->SetCookieWithDetails(cm, @@ -254,9 +278,14 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> { "sec_dom", "X", ".math.harvard.edu", "/", base::Time(), true, false)); EXPECT_TRUE(this->SetCookieWithDetails(cm, - url_top_level_domain_plus_2_secure, - "sec_host", "X", "", "/", - base::Time(), true, false)); + url_top_level_domain_plus_2_secure, + "sec_host", + "X", + std::string(), + "/", + base::Time(), + true, + false)); // Domain path cookies EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, @@ -269,14 +298,24 @@ class CookieMonsterTest : public CookieStoreTest<CookieMonsterTestTraits> { base::Time(), false, false)); // Host path cookies - EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, - "host_path_1", "X", - "", "/dir1", - base::Time(), false, false)); - EXPECT_TRUE(this->SetCookieWithDetails(cm, url_top_level_domain_plus_2, - "host_path_2", "X", - "", "/dir1/dir2", - base::Time(), false, false)); + EXPECT_TRUE(this->SetCookieWithDetails(cm, + url_top_level_domain_plus_2, + "host_path_1", + "X", + std::string(), + "/dir1", + base::Time(), + false, + false)); + EXPECT_TRUE(this->SetCookieWithDetails(cm, + url_top_level_domain_plus_2, + "host_path_2", + "X", + std::string(), + "/dir1/dir2", + base::Time(), + false, + false)); EXPECT_EQ(13U, this->GetAllCookies(cm).size()); } @@ -2205,7 +2244,7 @@ TEST_F(CookieMonsterTest, PersisentCookieStorageTest) { EXPECT_EQ(CookieStoreCommand::ADD, store->commands()[0].type); // Remove it. EXPECT_TRUE(SetCookie(cm, url_google_,"A=B; max-age=0")); - this->MatchCookieLines("", GetCookies(cm, url_google_)); + this->MatchCookieLines(std::string(), GetCookies(cm, url_google_)); ASSERT_EQ(2u, store->commands().size()); EXPECT_EQ(CookieStoreCommand::REMOVE, store->commands()[1].type); diff --git a/net/cookies/cookie_store_test_helpers.cc b/net/cookies/cookie_store_test_helpers.cc index e499538..6ae4357d 100644 --- a/net/cookies/cookie_store_test_helpers.cc +++ b/net/cookies/cookie_store_test_helpers.cc @@ -90,7 +90,7 @@ std::string DelayedCookieMonster::GetCookiesWithOptions( const GURL& url, const CookieOptions& options) { ADD_FAILURE(); - return ""; + return std::string(); } void DelayedCookieMonster::DeleteCookie(const GURL& url, diff --git a/net/cookies/cookie_store_unittest.h b/net/cookies/cookie_store_unittest.h index 134a193..0d2d7ed 100644 --- a/net/cookies/cookie_store_unittest.h +++ b/net/cookies/cookie_store_unittest.h @@ -275,9 +275,10 @@ TYPED_TEST_P(CookieStoreTest, DomainTest) { // Test domain enforcement, should fail on a sub-domain or something too deep. EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "I=J; domain=.izzle")); - this->MatchCookieLines("", this->GetCookies(cs, GURL("http://a.izzle"))); - EXPECT_FALSE(this->SetCookie(cs, this->url_google_, - "K=L; domain=.bla.www.google.izzle")); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, GURL("http://a.izzle"))); + EXPECT_FALSE(this->SetCookie( + cs, this->url_google_, "K=L; domain=.bla.www.google.izzle")); this->MatchCookieLines("C=D; E=F; G=H", this->GetCookies(cs, GURL("http://bla.www.google.izzle"))); this->MatchCookieLines("A=B; C=D; E=F; G=H", @@ -292,7 +293,8 @@ TYPED_TEST_P(CookieStoreTest, DomainWithTrailingDotTest) { "a=1; domain=.www.google.com.")); EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "b=2; domain=.www.google.com..")); - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); } // Test that cookies can bet set on higher level domains. @@ -366,7 +368,7 @@ TYPED_TEST_P(CookieStoreTest, InvalidDomainTest) { EXPECT_FALSE(this->SetCookie(cs, url_foobar, "o=15; domain=.foo.bar.com#sup")); - this->MatchCookieLines("", this->GetCookies(cs, url_foobar)); + this->MatchCookieLines(std::string(), this->GetCookies(cs, url_foobar)); } { @@ -377,7 +379,7 @@ TYPED_TEST_P(CookieStoreTest, InvalidDomainTest) { GURL url_foocom("http://foo.com.com"); EXPECT_FALSE(this->SetCookie(cs, url_foocom, "a=1; domain=.foo.com.com.com")); - this->MatchCookieLines("", this->GetCookies(cs, url_foocom)); + this->MatchCookieLines(std::string(), this->GetCookies(cs, url_foocom)); } } @@ -402,8 +404,8 @@ TYPED_TEST_P(CookieStoreTest, DomainWithoutLeadingDotTest) { this->MatchCookieLines("a=1", this->GetCookies(cs, url)); this->MatchCookieLines("a=1", this->GetCookies(cs, GURL("http://sub.www.google.com"))); - this->MatchCookieLines("", - this->GetCookies(cs, GURL("http://something-else.com"))); + this->MatchCookieLines( + std::string(), this->GetCookies(cs, GURL("http://something-else.com"))); } } @@ -429,11 +431,11 @@ TYPED_TEST_P(CookieStoreTest, TestIpAddress) { scoped_refptr<CookieStore> cs(this->GetCookieStore()); EXPECT_FALSE(this->SetCookie(cs, url_ip, "b=2; domain=.1.2.3.4")); EXPECT_FALSE(this->SetCookie(cs, url_ip, "c=3; domain=.3.4")); - this->MatchCookieLines("", this->GetCookies(cs, url_ip)); + this->MatchCookieLines(std::string(), this->GetCookies(cs, url_ip)); // It should be allowed to set a cookie if domain= matches the IP address // exactly. This matches IE/Firefox, even though it seems a bit wrong. EXPECT_FALSE(this->SetCookie(cs, url_ip, "b=2; domain=1.2.3.3")); - this->MatchCookieLines("", this->GetCookies(cs, url_ip)); + this->MatchCookieLines(std::string(), this->GetCookies(cs, url_ip)); EXPECT_TRUE(this->SetCookie(cs, url_ip, "b=2; domain=1.2.3.4")); this->MatchCookieLines("b=2", this->GetCookies(cs, url_ip)); } @@ -451,10 +453,12 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) { this->MatchCookieLines("a=1", this->GetCookies(cs, url)); // Make sure it doesn't show up for a normal .com, it should be a host // not a domain cookie. - this->MatchCookieLines("", + this->MatchCookieLines( + std::string(), this->GetCookies(cs, GURL("http://hopefully-no-cookies.com/"))); if (TypeParam::supports_non_dotted_domains) { - this->MatchCookieLines("", this->GetCookies(cs, GURL("http://.com/"))); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, GURL("http://.com/"))); } } @@ -465,7 +469,8 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) { if (TypeParam::supports_trailing_dots) { EXPECT_TRUE(this->SetCookie(cs, url, "a=1")); this->MatchCookieLines("a=1", this->GetCookies(cs, url)); - this->MatchCookieLines("", + this->MatchCookieLines( + std::string(), this->GetCookies(cs, GURL("http://hopefully-no-cookies.com./"))); } else { EXPECT_FALSE(this->SetCookie(cs, url, "a=1")); @@ -477,7 +482,7 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) { GURL url("http://a.b"); EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.b")); EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=b")); - this->MatchCookieLines("", this->GetCookies(cs, url)); + this->MatchCookieLines(std::string(), this->GetCookies(cs, url)); } { // Same test as above, but explicitly on a known TLD (com). @@ -485,7 +490,7 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) { GURL url("http://google.com"); EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.com")); EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=com")); - this->MatchCookieLines("", this->GetCookies(cs, url)); + this->MatchCookieLines(std::string(), this->GetCookies(cs, url)); } { // Make sure can't set cookie on TLD which is dotted. @@ -493,11 +498,12 @@ TYPED_TEST_P(CookieStoreTest, TestNonDottedAndTLD) { GURL url("http://google.co.uk"); EXPECT_FALSE(this->SetCookie(cs, url, "a=1; domain=.co.uk")); EXPECT_FALSE(this->SetCookie(cs, url, "b=2; domain=.uk")); - this->MatchCookieLines("", this->GetCookies(cs, url)); - this->MatchCookieLines("", + this->MatchCookieLines(std::string(), this->GetCookies(cs, url)); + this->MatchCookieLines( + std::string(), this->GetCookies(cs, GURL("http://something-else.co.uk"))); - this->MatchCookieLines("", - this->GetCookies(cs, GURL("http://something-else.uk"))); + this->MatchCookieLines( + std::string(), this->GetCookies(cs, GURL("http://something-else.uk"))); } { // Intranet URLs should only be able to set host cookies. @@ -533,9 +539,11 @@ TYPED_TEST_P(CookieStoreTest, TestHostEndsWithDot) { } // Make sure there weren't any side effects. - this->MatchCookieLines("", + this->MatchCookieLines( + std::string(), this->GetCookies(cs, GURL("http://hopefully-no-cookies.com/"))); - this->MatchCookieLines("", this->GetCookies(cs, GURL("http://.com/"))); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, GURL("http://.com/"))); } TYPED_TEST_P(CookieStoreTest, InvalidScheme) { @@ -552,7 +560,7 @@ TYPED_TEST_P(CookieStoreTest, InvalidScheme_Read) { scoped_refptr<CookieStore> cs(this->GetCookieStore()); EXPECT_TRUE(this->SetCookie(cs, GURL(kUrlGoogle), kValidDomainCookieLine)); - this->MatchCookieLines("", this->GetCookies(cs, GURL(kUrlFtp))); + this->MatchCookieLines(std::string(), this->GetCookies(cs, GURL(kUrlFtp))); } TYPED_TEST_P(CookieStoreTest, PathTest) { @@ -565,8 +573,9 @@ TYPED_TEST_P(CookieStoreTest, PathTest) { this->MatchCookieLines("A=B", this->GetCookies(cs, GURL(url + "/wee/war/more/more"))); if (!TypeParam::has_path_prefix_bug) - this->MatchCookieLines("", this->GetCookies(cs, GURL(url + "/weehee"))); - this->MatchCookieLines("", this->GetCookies(cs, GURL(url + "/"))); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, GURL(url + "/weehee"))); + this->MatchCookieLines(std::string(), this->GetCookies(cs, GURL(url + "/"))); // If we add a 0 length path, it should default to / EXPECT_TRUE(this->SetCookie(cs, GURL(url), "A=C; path=")); @@ -612,15 +621,17 @@ TYPED_TEST_P(CookieStoreTest, HttpOnlyTest) { options)); // Check httponly read protection. - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); - this->MatchCookieLines("A=B", - this->GetCookiesWithOptions(cs, this->url_google_, options)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines( + "A=B", this->GetCookiesWithOptions(cs, this->url_google_, options)); // Check httponly overwrite protection. EXPECT_FALSE(this->SetCookie(cs, this->url_google_, "A=C")); - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); - this->MatchCookieLines("A=B", - this->GetCookiesWithOptions(cs, this->url_google_, options)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines( + "A=B", this->GetCookiesWithOptions(cs, this->url_google_, options)); EXPECT_TRUE(this->SetCookieWithOptions(cs, this->url_google_, "A=C", options)); this->MatchCookieLines("A=C", this->GetCookies(cs, this->url_google_)); @@ -645,7 +656,7 @@ TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) { // Delete it via Max-Age. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, std::string(kValidCookieLine) + "; max-age=0")); - this->MatchCookieLineWithTimeout(cs, this->url_google_, ""); + this->MatchCookieLineWithTimeout(cs, this->url_google_, std::string()); // Create a session cookie. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, kValidCookieLine)); @@ -654,7 +665,8 @@ TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) { EXPECT_TRUE(this->SetCookie(cs, this->url_google_, std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT")); - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); // Create a persistent cookie. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, @@ -665,7 +677,7 @@ TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) { // Delete it via Max-Age. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, std::string(kValidCookieLine) + "; max-age=0")); - this->MatchCookieLineWithTimeout(cs, this->url_google_, ""); + this->MatchCookieLineWithTimeout(cs, this->url_google_, std::string()); // Create a persistent cookie. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, @@ -676,7 +688,8 @@ TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) { EXPECT_TRUE(this->SetCookie(cs, this->url_google_, std::string(kValidCookieLine) + "; expires=Mon, 18-Apr-1977 22:50:13 GMT")); - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); // Create a persistent cookie. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, @@ -703,7 +716,8 @@ TYPED_TEST_P(CookieStoreTest, TestCookieDeletion) { EXPECT_TRUE(this->SetCookie(cs, this->url_google_, std::string(kValidCookieLine) + "; expires=Thu, 1-Jan-1970 00:00:00 GMT")); - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); } TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) { @@ -731,7 +745,8 @@ TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) { // Remove the cookie with an interval defined by two dates. EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, next_minute)); // Check that the cookie disappeared. - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); // Add another cookie. EXPECT_TRUE(this->SetCookie(cs, this->url_google_, "C=D")); @@ -741,7 +756,8 @@ TYPED_TEST_P(CookieStoreTest, TestDeleteAllCreatedBetween) { // Remove the cookie with a null ending time. EXPECT_EQ(1, this->DeleteCreatedBetween(cs, last_minute, base::Time())); // Check that the cookie disappeared. - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); } TYPED_TEST_P(CookieStoreTest, TestSecure) { @@ -753,11 +769,13 @@ TYPED_TEST_P(CookieStoreTest, TestSecure) { EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "A=B; secure")); // The secure should overwrite the non-secure. - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); this->MatchCookieLines("A=B", this->GetCookies(cs, this->url_google_secure_)); EXPECT_TRUE(this->SetCookie(cs, this->url_google_secure_, "D=E; secure")); - this->MatchCookieLines("", this->GetCookies(cs, this->url_google_)); + this->MatchCookieLines(std::string(), + this->GetCookies(cs, this->url_google_)); this->MatchCookieLines("A=B; D=E", this->GetCookies(cs, this->url_google_secure_)); diff --git a/net/cookies/parsed_cookie.cc b/net/cookies/parsed_cookie.cc index 5cd542d..ecb8712 100644 --- a/net/cookies/parsed_cookie.cc +++ b/net/cookies/parsed_cookie.cc @@ -424,7 +424,7 @@ bool ParsedCookie::SetBool(size_t* index, ClearAttributePair(*index); return true; } else { - return SetAttributePair(index, key, ""); + return SetAttributePair(index, key, std::string()); } } diff --git a/net/cookies/parsed_cookie_unittest.cc b/net/cookies/parsed_cookie_unittest.cc index 3729650..57de115 100644 --- a/net/cookies/parsed_cookie_unittest.cc +++ b/net/cookies/parsed_cookie_unittest.cc @@ -208,7 +208,7 @@ TEST(ParsedCookieTest, InvalidTooLong) { } TEST(ParsedCookieTest, InvalidEmpty) { - ParsedCookie pc(""); + ParsedCookie pc((std::string())); EXPECT_FALSE(pc.IsValid()); } @@ -259,7 +259,7 @@ TEST(ParsedCookieTest, SerializeCookieLine) { TEST(ParsedCookieTest, SetNameAndValue) { - ParsedCookie empty(""); + ParsedCookie empty((std::string())); EXPECT_FALSE(empty.IsValid()); EXPECT_FALSE(empty.SetDomain("foobar.com")); EXPECT_TRUE(empty.SetName("name")); @@ -282,7 +282,7 @@ TEST(ParsedCookieTest, SetNameAndValue) { EXPECT_EQ("name=value", pc.ToCookieLine()); EXPECT_TRUE(pc.IsValid()); - EXPECT_FALSE(pc.SetName("")); + EXPECT_FALSE(pc.SetName(std::string())); EXPECT_EQ("name=value", pc.ToCookieLine()); EXPECT_TRUE(pc.IsValid()); @@ -303,7 +303,7 @@ TEST(ParsedCookieTest, SetNameAndValue) { EXPECT_EQ("test=\"foobar\"", pc.ToCookieLine()); EXPECT_TRUE(pc.IsValid()); - EXPECT_TRUE(pc.SetValue("")); + EXPECT_TRUE(pc.SetValue(std::string())); EXPECT_EQ("test=", pc.ToCookieLine()); EXPECT_TRUE(pc.IsValid()); } @@ -313,7 +313,7 @@ TEST(ParsedCookieTest, SetAttributes) { EXPECT_TRUE(pc.IsValid()); // Clear an unset attribute. - EXPECT_TRUE(pc.SetDomain("")); + EXPECT_TRUE(pc.SetDomain(std::string())); EXPECT_FALSE(pc.HasDomain()); EXPECT_EQ("name=value", pc.ToCookieLine()); EXPECT_TRUE(pc.IsValid()); @@ -355,10 +355,10 @@ TEST(ParsedCookieTest, SetAttributes) { pc.ToCookieLine()); // Clear the rest and change the name and value. - EXPECT_TRUE(pc.SetDomain("")); - EXPECT_TRUE(pc.SetPath("")); - EXPECT_TRUE(pc.SetExpires("")); - EXPECT_TRUE(pc.SetMaxAge("")); + EXPECT_TRUE(pc.SetDomain(std::string())); + EXPECT_TRUE(pc.SetPath(std::string())); + EXPECT_TRUE(pc.SetExpires(std::string())); + EXPECT_TRUE(pc.SetMaxAge(std::string())); EXPECT_TRUE(pc.SetIsSecure(false)); EXPECT_TRUE(pc.SetIsHttpOnly(false)); EXPECT_TRUE(pc.SetName("name2")); diff --git a/net/dns/host_resolver_impl_unittest.cc b/net/dns/host_resolver_impl_unittest.cc index c9ebec0..26bebeb 100644 --- a/net/dns/host_resolver_impl_unittest.cc +++ b/net/dns/host_resolver_impl_unittest.cc @@ -107,7 +107,7 @@ class MockHostResolverProc : public HostResolverProc { void AddRule(const std::string& hostname, AddressFamily family, const std::string& ip_list) { AddressList result; - int rv = ParseAddressList(ip_list, "", &result); + int rv = ParseAddressList(ip_list, std::string(), &result); DCHECK_EQ(OK, rv); AddRule(hostname, family, result); } @@ -115,7 +115,7 @@ class MockHostResolverProc : public HostResolverProc { void AddRuleForAllFamilies(const std::string& hostname, const std::string& ip_list) { AddressList result; - int rv = ParseAddressList(ip_list, "", &result); + int rv = ParseAddressList(ip_list, std::string(), &result); DCHECK_EQ(OK, rv); AddRule(hostname, ADDRESS_FAMILY_UNSPECIFIED, result); AddRule(hostname, ADDRESS_FAMILY_IPV4, result); @@ -137,7 +137,7 @@ class MockHostResolverProc : public HostResolverProc { --num_slots_available_; --num_requests_waiting_; if (rules_.empty()) { - int rv = ParseAddressList("127.0.0.1", "", addrlist); + int rv = ParseAddressList("127.0.0.1", std::string(), addrlist); DCHECK_EQ(OK, rv); return OK; } @@ -527,7 +527,8 @@ TEST_F(HostResolverImplTest, AsynchronousLookup) { } TEST_F(HostResolverImplTest, FailedAsynchronousLookup) { - proc_->AddRuleForAllFamilies("", "0.0.0.0"); // Default to failures. + proc_->AddRuleForAllFamilies(std::string(), + "0.0.0.0"); // Default to failures. proc_->SignalMultiple(1u); Request* req = CreateRequest("just.testing", 80); @@ -582,7 +583,7 @@ TEST_F(HostResolverImplTest, NumericIPv6Address) { } TEST_F(HostResolverImplTest, EmptyHost) { - Request* req = CreateRequest("", 5555); + Request* req = CreateRequest(std::string(), 5555); EXPECT_EQ(ERR_NAME_NOT_RESOLVED, req->Resolve()); } @@ -1344,7 +1345,8 @@ TEST_F(HostResolverImplDnsTest, ServeFromHosts) { DnsConfig config = CreateValidDnsConfig(); ChangeDnsConfig(config); - proc_->AddRuleForAllFamilies("", ""); // Default to failures. + proc_->AddRuleForAllFamilies(std::string(), + std::string()); // Default to failures. proc_->SignalMultiple(1u); // For the first request which misses. Request* req0 = CreateRequest("er_ipv4", 80); @@ -1396,7 +1398,8 @@ TEST_F(HostResolverImplDnsTest, ServeFromHosts) { TEST_F(HostResolverImplDnsTest, BypassDnsTask) { ChangeDnsConfig(CreateValidDnsConfig()); - proc_->AddRuleForAllFamilies("", ""); // Default to failures. + proc_->AddRuleForAllFamilies(std::string(), + std::string()); // Default to failures. EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local", 80)->Resolve()); EXPECT_EQ(ERR_IO_PENDING, CreateRequest("ok.local.", 80)->Resolve()); @@ -1416,7 +1419,8 @@ TEST_F(HostResolverImplDnsTest, BypassDnsTask) { TEST_F(HostResolverImplDnsTest, DisableDnsClientOnPersistentFailure) { ChangeDnsConfig(CreateValidDnsConfig()); - proc_->AddRuleForAllFamilies("", ""); // Default to failures. + proc_->AddRuleForAllFamilies(std::string(), + std::string()); // Default to failures. // Check that DnsTask works. Request* req = CreateRequest("ok_1", 80); @@ -1470,7 +1474,7 @@ TEST_F(HostResolverImplDnsTest, DontDisableDnsClientOnSporadicFailure) { EXPECT_EQ(OK, requests_[i]->WaitForResult()) << i; // Make |proc_| default to failures. - proc_->AddRuleForAllFamilies("", ""); + proc_->AddRuleForAllFamilies(std::string(), std::string()); // DnsTask should still be enabled. Request* req = CreateRequest("ok_last", 80); diff --git a/net/dns/mapped_host_resolver_unittest.cc b/net/dns/mapped_host_resolver_unittest.cc index 8da95e1..d859466 100644 --- a/net/dns/mapped_host_resolver_unittest.cc +++ b/net/dns/mapped_host_resolver_unittest.cc @@ -18,7 +18,7 @@ namespace { std::string FirstAddress(const AddressList& address_list) { if (address_list.empty()) - return ""; + return std::string(); return address_list.front().ToString(); } @@ -171,7 +171,7 @@ TEST(MappedHostResolverTest, ParseInvalidRules) { new MappedHostResolver(scoped_ptr<HostResolver>())); EXPECT_FALSE(resolver->AddRuleFromString("xyz")); - EXPECT_FALSE(resolver->AddRuleFromString("")); + EXPECT_FALSE(resolver->AddRuleFromString(std::string())); EXPECT_FALSE(resolver->AddRuleFromString(" ")); EXPECT_FALSE(resolver->AddRuleFromString("EXCLUDE")); EXPECT_FALSE(resolver->AddRuleFromString("EXCLUDE foo bar")); diff --git a/net/dns/mock_host_resolver.cc b/net/dns/mock_host_resolver.cc index fb03836..e6ecf59 100644 --- a/net/dns/mock_host_resolver.cc +++ b/net/dns/mock_host_resolver.cc @@ -256,8 +256,13 @@ void RuleBasedHostResolverProc::AddRuleForAddressFamily( DCHECK(!replacement.empty()); HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY | HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6; - Rule rule(Rule::kResolverTypeSystem, host_pattern, address_family, flags, - replacement, "", 0); + Rule rule(Rule::kResolverTypeSystem, + host_pattern, + address_family, + flags, + replacement, + std::string(), + 0); rules_.push_back(rule); } @@ -286,8 +291,13 @@ void RuleBasedHostResolverProc::AddRuleWithLatency( DCHECK(!replacement.empty()); HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY | HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6; - Rule rule(Rule::kResolverTypeSystem, host_pattern, ADDRESS_FAMILY_UNSPECIFIED, - flags, replacement, "", latency_ms); + Rule rule(Rule::kResolverTypeSystem, + host_pattern, + ADDRESS_FAMILY_UNSPECIFIED, + flags, + replacement, + std::string(), + latency_ms); rules_.push_back(rule); } @@ -295,8 +305,13 @@ void RuleBasedHostResolverProc::AllowDirectLookup( const std::string& host_pattern) { HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY | HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6; - Rule rule(Rule::kResolverTypeSystem, host_pattern, ADDRESS_FAMILY_UNSPECIFIED, - flags, "", "", 0); + Rule rule(Rule::kResolverTypeSystem, + host_pattern, + ADDRESS_FAMILY_UNSPECIFIED, + flags, + std::string(), + std::string(), + 0); rules_.push_back(rule); } @@ -304,8 +319,13 @@ void RuleBasedHostResolverProc::AddSimulatedFailure( const std::string& host_pattern) { HostResolverFlags flags = HOST_RESOLVER_LOOPBACK_ONLY | HOST_RESOLVER_DEFAULT_FAMILY_SET_DUE_TO_NO_IPV6; - Rule rule(Rule::kResolverTypeFail, host_pattern, ADDRESS_FAMILY_UNSPECIFIED, - flags, "", "", 0); + Rule rule(Rule::kResolverTypeFail, + host_pattern, + ADDRESS_FAMILY_UNSPECIFIED, + flags, + std::string(), + std::string(), + 0); rules_.push_back(rule); } diff --git a/net/dns/single_request_host_resolver_unittest.cc b/net/dns/single_request_host_resolver_unittest.cc index 3e2ea1e..1b0198f 100644 --- a/net/dns/single_request_host_resolver_unittest.cc +++ b/net/dns/single_request_host_resolver_unittest.cc @@ -68,7 +68,7 @@ TEST(SingleRequestHostResolverTest, NormalResolve) { // Create a host resolver dependency that returns address "199.188.1.166" // for resolutions of "watsup". MockHostResolver resolver; - resolver.rules()->AddIPLiteralRule("watsup", "199.188.1.166", ""); + resolver.rules()->AddIPLiteralRule("watsup", "199.188.1.166", std::string()); SingleRequestHostResolver single_request_resolver(&resolver); diff --git a/net/ftp/ftp_util.cc b/net/ftp/ftp_util.cc index 0eab465..68307a2 100644 --- a/net/ftp/ftp_util.cc +++ b/net/ftp/ftp_util.cc @@ -107,7 +107,7 @@ std::string FtpUtil::VMSPathToUnix(const std::string& vms_path) { std::string result(vms_path); if (vms_path[0] == '[') { // It's a relative path. - ReplaceFirstSubstringAfterOffset(&result, 0, "[.", ""); + ReplaceFirstSubstringAfterOffset(&result, 0, "[.", std::string()); } else { // It's an absolute path. result.insert(0, "/"); diff --git a/net/http/http_auth.cc b/net/http/http_auth.cc index fb7fc5d..9e9410b 100644 --- a/net/http/http_auth.cc +++ b/net/http/http_auth.cc @@ -146,7 +146,7 @@ std::string HttpAuth::GetChallengeHeaderName(Target target) { return "WWW-Authenticate"; default: NOTREACHED(); - return ""; + return std::string(); } } @@ -159,7 +159,7 @@ std::string HttpAuth::GetAuthorizationHeaderName(Target target) { return HttpRequestHeaders::kAuthorization; default: NOTREACHED(); - return ""; + return std::string(); } } @@ -172,7 +172,7 @@ std::string HttpAuth::GetAuthTargetString(Target target) { return "server"; default: NOTREACHED(); - return ""; + return std::string(); } } diff --git a/net/http/http_auth_cache_unittest.cc b/net/http/http_auth_cache_unittest.cc index af3b25c..0bdb280 100644 --- a/net/http/http_auth_cache_unittest.cc +++ b/net/http/http_auth_cache_unittest.cc @@ -106,11 +106,13 @@ TEST(HttpAuthCacheTest, Basic) { new MockAuthHandler(HttpAuth::AUTH_SCHEME_BASIC, kRealm3, HttpAuth::AUTH_PROXY)); - cache.Add(origin, realm3_basic_handler->realm(), - realm3_basic_handler->auth_scheme(), "Basic realm=Realm3", - CreateASCIICredentials("realm3-basic-user", - "realm3-basic-password"), - ""); + cache.Add( + origin, + realm3_basic_handler->realm(), + realm3_basic_handler->auth_scheme(), + "Basic realm=Realm3", + CreateASCIICredentials("realm3-basic-user", "realm3-basic-password"), + std::string()); scoped_ptr<HttpAuthHandler> realm3_digest_handler( new MockAuthHandler(HttpAuth::AUTH_SCHEME_DIGEST, @@ -205,7 +207,7 @@ TEST(HttpAuthCacheTest, Basic) { // Negative tests: entry = cache.LookupByPath(origin, "/foo3/index.html"); EXPECT_FALSE(realm2_entry == entry); - entry = cache.LookupByPath(origin, ""); + entry = cache.LookupByPath(origin, std::string()); EXPECT_FALSE(realm2_entry == entry); // Confirm we find the same realm, different auth scheme by path lookup @@ -231,7 +233,7 @@ TEST(HttpAuthCacheTest, Basic) { EXPECT_FALSE(realm3DigestEntry == entry); // Lookup using empty path (may be used for proxy). - entry = cache.LookupByPath(origin, ""); + entry = cache.LookupByPath(origin, std::string()); EXPECT_FALSE(NULL == entry); EXPECT_EQ(HttpAuth::AUTH_SCHEME_BASIC, entry->scheme()); EXPECT_EQ(kRealm3, entry->realm()); @@ -540,7 +542,10 @@ class HttpAuthCacheEvictionTest : public testing::Test { } void AddPathToRealm(int realm_i, int path_i) { - cache_.Add(origin_, GenerateRealm(realm_i), HttpAuth::AUTH_SCHEME_BASIC, "", + cache_.Add(origin_, + GenerateRealm(realm_i), + HttpAuth::AUTH_SCHEME_BASIC, + std::string(), AuthCredentials(kUsername, kPassword), GeneratePath(realm_i, path_i)); } diff --git a/net/http/http_auth_filter_unittest.cc b/net/http/http_auth_filter_unittest.cc index 0aab9d4..e6891dd 100644 --- a/net/http/http_auth_filter_unittest.cc +++ b/net/http/http_auth_filter_unittest.cc @@ -35,22 +35,17 @@ struct UrlData { }; static const UrlData urls[] = { - { GURL(""), - HttpAuth::AUTH_NONE, false, 0 }, - { GURL("http://foo.cn"), - HttpAuth::AUTH_PROXY, true, ALL_SERVERS_MATCH }, - { GURL("http://foo.cn"), - HttpAuth::AUTH_SERVER, false, 0 }, - { GURL("http://slashdot.org"), - HttpAuth::AUTH_NONE, false, 0 }, - { GURL("http://www.google.com"), - HttpAuth::AUTH_SERVER, true, 1 << 0 }, - { GURL("http://www.google.com"), - HttpAuth::AUTH_PROXY, true, ALL_SERVERS_MATCH }, + { GURL(std::string()), HttpAuth::AUTH_NONE, false, 0 }, + { GURL("http://foo.cn"), HttpAuth::AUTH_PROXY, true, ALL_SERVERS_MATCH }, + { GURL("http://foo.cn"), HttpAuth::AUTH_SERVER, false, 0 }, + { GURL("http://slashdot.org"), HttpAuth::AUTH_NONE, false, 0 }, + { GURL("http://www.google.com"), HttpAuth::AUTH_SERVER, true, 1 << 0 }, + { GURL("http://www.google.com"), HttpAuth::AUTH_PROXY, true, + ALL_SERVERS_MATCH }, { GURL("https://login.facebook.com/login.php?login_attempt=1"), HttpAuth::AUTH_NONE, false, 0 }, - { GURL("http://codereview.chromium.org/634002/show"), - HttpAuth::AUTH_SERVER, true, 1 << 3 }, + { GURL("http://codereview.chromium.org/634002/show"), HttpAuth::AUTH_SERVER, + true, 1 << 3 }, { GURL("http://code.google.com/p/chromium/issues/detail?id=34505"), HttpAuth::AUTH_SERVER, true, 1 << 0 }, { GURL("http://code.google.com/p/chromium/issues/list?can=2&q=label:" @@ -77,7 +72,7 @@ static const UrlData urls[] = { TEST(HttpAuthFilterTest, EmptyFilter) { // Create an empty filter - HttpAuthFilterWhitelist filter(""); + HttpAuthFilterWhitelist filter((std::string())); for (size_t i = 0; i < arraysize(urls); i++) { EXPECT_EQ(urls[i].target == HttpAuth::AUTH_PROXY, filter.IsValid(urls[i].url, urls[i].target)) diff --git a/net/http/http_auth_gssapi_posix_unittest.cc b/net/http/http_auth_gssapi_posix_unittest.cc index cbf4d3d..1c3d12b 100644 --- a/net/http/http_auth_gssapi_posix_unittest.cc +++ b/net/http/http_auth_gssapi_posix_unittest.cc @@ -76,7 +76,7 @@ TEST(HttpAuthGSSAPIPOSIXTest, GSSAPIStartup) { // TODO(ahendrickson): Manipulate the libraries and paths to test each of the // libraries we expect, and also whether or not they have the interface // functions we want. - scoped_ptr<GSSAPILibrary> gssapi(new GSSAPISharedLibrary("")); + scoped_ptr<GSSAPILibrary> gssapi(new GSSAPISharedLibrary(std::string())); DCHECK(gssapi.get()); EXPECT_TRUE(gssapi.get()->Init()); } diff --git a/net/http/http_auth_handler_digest.cc b/net/http/http_auth_handler_digest.cc index bfc8312..cc90b52 100644 --- a/net/http/http_auth_handler_digest.cc +++ b/net/http/http_auth_handler_digest.cc @@ -270,12 +270,12 @@ bool HttpAuthHandlerDigest::ParseChallengeProperty(const std::string& name, std::string HttpAuthHandlerDigest::QopToString(QualityOfProtection qop) { switch (qop) { case QOP_UNSPECIFIED: - return ""; + return std::string(); case QOP_AUTH: return "auth"; default: NOTREACHED(); - return ""; + return std::string(); } } @@ -284,14 +284,14 @@ std::string HttpAuthHandlerDigest::AlgorithmToString( DigestAlgorithm algorithm) { switch (algorithm) { case ALGORITHM_UNSPECIFIED: - return ""; + return std::string(); case ALGORITHM_MD5: return "MD5"; case ALGORITHM_MD5_SESS: return "MD5-sess"; default: NOTREACHED(); - return ""; + return std::string(); } } diff --git a/net/http/http_auth_unittest.cc b/net/http/http_auth_unittest.cc index 88c7f95..ff63c9b 100644 --- a/net/http/http_auth_unittest.cc +++ b/net/http/http_auth_unittest.cc @@ -304,7 +304,7 @@ TEST(HttpAuthTest, ChallengeTokenizerMismatchedQuotesNoValue) { EXPECT_TRUE(parameters.GetNext()); EXPECT_TRUE(parameters.valid()); EXPECT_EQ(std::string("realm"), parameters.name()); - EXPECT_EQ(std::string(""), parameters.value()); + EXPECT_EQ(std::string(), parameters.value()); EXPECT_FALSE(parameters.GetNext()); } diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc index a2a9dfc..27c591d 100644 --- a/net/http/http_cache.cc +++ b/net/http/http_cache.cc @@ -445,7 +445,7 @@ int HttpCache::CreateBackend(disk_cache::Backend** backend, // This is the only operation that we can do that is not related to any given // entry, so we use an empty key for it. - PendingOp* pending_op = GetPendingOp(""); + PendingOp* pending_op = GetPendingOp(std::string()); if (pending_op->writer) { if (!callback.is_null()) pending_op->pending_queue.push_back(item.release()); @@ -477,7 +477,7 @@ int HttpCache::GetBackendForTransaction(Transaction* trans) { WorkItem* item = new WorkItem( WI_CREATE_BACKEND, trans, net::CompletionCallback(), NULL); - PendingOp* pending_op = GetPendingOp(""); + PendingOp* pending_op = GetPendingOp(std::string()); DCHECK(pending_op->writer); pending_op->pending_queue.push_back(item); return ERR_IO_PENDING; @@ -896,7 +896,7 @@ void HttpCache::RemovePendingTransaction(Transaction* trans) { return; if (building_backend_) { - PendingOpsMap::const_iterator j = pending_ops_.find(""); + PendingOpsMap::const_iterator j = pending_ops_.find(std::string()); if (j != pending_ops_.end()) found = RemovePendingTransactionFromPendingOp(j->second, trans); diff --git a/net/http/http_network_transaction.cc b/net/http/http_network_transaction.cc index 54d79f3..467eb94 100644 --- a/net/http/http_network_transaction.cc +++ b/net/http/http_network_transaction.cc @@ -929,7 +929,7 @@ int HttpNetworkTransaction::DoReadHeadersComplete(int result) { // We treat any other 1xx in this same way (although in practice getting // a 1xx that isn't a 100 is rare). if (response_.headers->response_code() / 100 == 1) { - response_.headers = new HttpResponseHeaders(""); + response_.headers = new HttpResponseHeaders(std::string()); next_state_ = STATE_READ_HEADERS; return OK; } diff --git a/net/http/http_network_transaction_spdy2_unittest.cc b/net/http/http_network_transaction_spdy2_unittest.cc index 3f81030..0da9f2e 100644 --- a/net/http/http_network_transaction_spdy2_unittest.cc +++ b/net/http/http_network_transaction_spdy2_unittest.cc @@ -461,12 +461,24 @@ CaptureGroupNameHttpProxySocketPool::CaptureGroupNameSocketPool( CertVerifier* /* cert_verifier */) : HttpProxyClientSocketPool(0, 0, NULL, host_resolver, NULL, NULL, NULL) {} -template<> +template <> CaptureGroupNameSSLSocketPool::CaptureGroupNameSocketPool( HostResolver* host_resolver, CertVerifier* cert_verifier) - : SSLClientSocketPool(0, 0, NULL, host_resolver, cert_verifier, NULL, - NULL, "", NULL, NULL, NULL, NULL, NULL, NULL) {} + : SSLClientSocketPool(0, + 0, + NULL, + host_resolver, + cert_verifier, + NULL, + NULL, + std::string(), + NULL, + NULL, + NULL, + NULL, + NULL, + NULL) {} //----------------------------------------------------------------------------- @@ -8851,7 +8863,10 @@ TEST_F(HttpNetworkTransactionSpdy2Test, SSLClientSocketContext context; context.cert_verifier = session_deps.cert_verifier.get(); ssl_connection->set_socket(session_deps.socket_factory->CreateSSLClientSocket( - connection.release(), HostPortPair("" , 443), ssl_config, context)); + connection.release(), + HostPortPair(std::string(), 443), + ssl_config, + context)); EXPECT_EQ(ERR_IO_PENDING, ssl_connection->socket()->Connect(callback.callback())); EXPECT_EQ(OK, callback.WaitForResult()); diff --git a/net/http/http_network_transaction_spdy3_unittest.cc b/net/http/http_network_transaction_spdy3_unittest.cc index 3076326..8a90c7b 100644 --- a/net/http/http_network_transaction_spdy3_unittest.cc +++ b/net/http/http_network_transaction_spdy3_unittest.cc @@ -461,12 +461,24 @@ CaptureGroupNameHttpProxySocketPool::CaptureGroupNameSocketPool( CertVerifier* /* cert_verifier */) : HttpProxyClientSocketPool(0, 0, NULL, host_resolver, NULL, NULL, NULL) {} -template<> +template <> CaptureGroupNameSSLSocketPool::CaptureGroupNameSocketPool( HostResolver* host_resolver, CertVerifier* cert_verifier) - : SSLClientSocketPool(0, 0, NULL, host_resolver, cert_verifier, NULL, - NULL, "", NULL, NULL, NULL, NULL, NULL, NULL) {} + : SSLClientSocketPool(0, + 0, + NULL, + host_resolver, + cert_verifier, + NULL, + NULL, + std::string(), + NULL, + NULL, + NULL, + NULL, + NULL, + NULL) {} //----------------------------------------------------------------------------- @@ -8827,7 +8839,10 @@ TEST_F(HttpNetworkTransactionSpdy3Test, SSLClientSocketContext context; context.cert_verifier = session_deps.cert_verifier.get(); ssl_connection->set_socket(session_deps.socket_factory->CreateSSLClientSocket( - connection.release(), HostPortPair("" , 443), ssl_config, context)); + connection.release(), + HostPortPair(std::string(), 443), + ssl_config, + context)); EXPECT_EQ(ERR_IO_PENDING, ssl_connection->socket()->Connect(callback.callback())); EXPECT_EQ(OK, callback.WaitForResult()); diff --git a/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc b/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc index 77ccbed..48ac42c 100644 --- a/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc +++ b/net/http/http_proxy_client_socket_pool_spdy2_unittest.cc @@ -47,26 +47,37 @@ class HttpProxyClientSocketPoolSpdy2Test : public TestWithHttpParam { protected: HttpProxyClientSocketPoolSpdy2Test() : ssl_config_(), - ignored_transport_socket_params_(new TransportSocketParams( - HostPortPair("proxy", 80), LOWEST, false, false, - OnHostResolutionCallback())), - ignored_ssl_socket_params_(new SSLSocketParams( - ignored_transport_socket_params_, NULL, NULL, - ProxyServer::SCHEME_DIRECT, HostPortPair("www.google.com", 443), - ssl_config_, 0, false, false)), + ignored_transport_socket_params_( + new TransportSocketParams(HostPortPair("proxy", 80), + LOWEST, + false, + false, + OnHostResolutionCallback())), + ignored_ssl_socket_params_( + new SSLSocketParams(ignored_transport_socket_params_, + NULL, + NULL, + ProxyServer::SCHEME_DIRECT, + HostPortPair("www.google.com", 443), + ssl_config_, + 0, + false, + false)), tcp_histograms_("MockTCP"), transport_socket_pool_( - kMaxSockets, kMaxSocketsPerGroup, + kMaxSockets, + kMaxSocketsPerGroup, &tcp_histograms_, session_deps_.deterministic_socket_factory.get()), ssl_histograms_("MockSSL"), - ssl_socket_pool_(kMaxSockets, kMaxSocketsPerGroup, + ssl_socket_pool_(kMaxSockets, + kMaxSocketsPerGroup, &ssl_histograms_, session_deps_.host_resolver.get(), session_deps_.cert_verifier.get(), NULL /* server_bound_cert_store */, NULL /* transport_security_state */, - "" /* ssl_session_cache_shard */, + std::string() /* ssl_session_cache_shard */, session_deps_.deterministic_socket_factory.get(), &transport_socket_pool_, NULL, @@ -77,13 +88,13 @@ class HttpProxyClientSocketPoolSpdy2Test : public TestWithHttpParam { http_proxy_histograms_("HttpProxyUnitTest"), ssl_data_(NULL), data_(NULL), - pool_(kMaxSockets, kMaxSocketsPerGroup, + pool_(kMaxSockets, + kMaxSocketsPerGroup, &http_proxy_histograms_, NULL, &transport_socket_pool_, &ssl_socket_pool_, - NULL) { - } + NULL) {} virtual ~HttpProxyClientSocketPoolSpdy2Test() { } @@ -115,17 +126,16 @@ class HttpProxyClientSocketPoolSpdy2Test : public TestWithHttpParam { // Returns the a correctly constructed HttpProxyParms // for the HTTP or HTTPS proxy. scoped_refptr<HttpProxySocketParams> GetParams(bool tunnel) { - return scoped_refptr<HttpProxySocketParams>( - new HttpProxySocketParams( - GetTcpParams(), - GetSslParams(), - GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"), - "", - HostPortPair("www.google.com", tunnel ? 443 : 80), - session_->http_auth_cache(), - session_->http_auth_handler_factory(), - session_->spdy_session_pool(), - tunnel)); + return scoped_refptr<HttpProxySocketParams>(new HttpProxySocketParams( + GetTcpParams(), + GetSslParams(), + GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"), + std::string(), + HostPortPair("www.google.com", tunnel ? 443 : 80), + session_->http_auth_cache(), + session_->http_auth_handler_factory(), + session_->spdy_session_pool(), + tunnel)); } scoped_refptr<HttpProxySocketParams> GetTunnelParams() { diff --git a/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc b/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc index 86924fc..36e5869 100644 --- a/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc +++ b/net/http/http_proxy_client_socket_pool_spdy3_unittest.cc @@ -47,26 +47,37 @@ class HttpProxyClientSocketPoolSpdy3Test : public TestWithHttpParam { protected: HttpProxyClientSocketPoolSpdy3Test() : ssl_config_(), - ignored_transport_socket_params_(new TransportSocketParams( - HostPortPair("proxy", 80), LOWEST, false, false, - OnHostResolutionCallback())), - ignored_ssl_socket_params_(new SSLSocketParams( - ignored_transport_socket_params_, NULL, NULL, - ProxyServer::SCHEME_DIRECT, HostPortPair("www.google.com", 443), - ssl_config_, 0, false, false)), + ignored_transport_socket_params_( + new TransportSocketParams(HostPortPair("proxy", 80), + LOWEST, + false, + false, + OnHostResolutionCallback())), + ignored_ssl_socket_params_( + new SSLSocketParams(ignored_transport_socket_params_, + NULL, + NULL, + ProxyServer::SCHEME_DIRECT, + HostPortPair("www.google.com", 443), + ssl_config_, + 0, + false, + false)), tcp_histograms_("MockTCP"), transport_socket_pool_( - kMaxSockets, kMaxSocketsPerGroup, + kMaxSockets, + kMaxSocketsPerGroup, &tcp_histograms_, session_deps_.deterministic_socket_factory.get()), ssl_histograms_("MockSSL"), - ssl_socket_pool_(kMaxSockets, kMaxSocketsPerGroup, + ssl_socket_pool_(kMaxSockets, + kMaxSocketsPerGroup, &ssl_histograms_, session_deps_.host_resolver.get(), session_deps_.cert_verifier.get(), NULL /* server_bound_cert_store */, NULL /* transport_security_state */, - "" /* ssl_session_cache_shard */, + std::string() /* ssl_session_cache_shard */, session_deps_.deterministic_socket_factory.get(), &transport_socket_pool_, NULL, @@ -77,13 +88,13 @@ class HttpProxyClientSocketPoolSpdy3Test : public TestWithHttpParam { http_proxy_histograms_("HttpProxyUnitTest"), ssl_data_(NULL), data_(NULL), - pool_(kMaxSockets, kMaxSocketsPerGroup, + pool_(kMaxSockets, + kMaxSocketsPerGroup, &http_proxy_histograms_, NULL, &transport_socket_pool_, &ssl_socket_pool_, - NULL) { - } + NULL) {} virtual ~HttpProxyClientSocketPoolSpdy3Test() { } @@ -115,17 +126,16 @@ class HttpProxyClientSocketPoolSpdy3Test : public TestWithHttpParam { // Returns the a correctly constructed HttpProxyParms // for the HTTP or HTTPS proxy. scoped_refptr<HttpProxySocketParams> GetParams(bool tunnel) { - return scoped_refptr<HttpProxySocketParams>( - new HttpProxySocketParams( - GetTcpParams(), - GetSslParams(), - GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"), - "", - HostPortPair("www.google.com", tunnel ? 443 : 80), - session_->http_auth_cache(), - session_->http_auth_handler_factory(), - session_->spdy_session_pool(), - tunnel)); + return scoped_refptr<HttpProxySocketParams>(new HttpProxySocketParams( + GetTcpParams(), + GetSslParams(), + GURL(tunnel ? "https://www.google.com/" : "http://www.google.com"), + std::string(), + HostPortPair("www.google.com", tunnel ? 443 : 80), + session_->http_auth_cache(), + session_->http_auth_handler_factory(), + session_->spdy_session_pool(), + tunnel)); } scoped_refptr<HttpProxySocketParams> GetTunnelParams() { diff --git a/net/http/http_security_headers_unittest.cc b/net/http/http_security_headers_unittest.cc index a142486..4f1e580 100644 --- a/net/http/http_security_headers_unittest.cc +++ b/net/http/http_security_headers_unittest.cc @@ -51,7 +51,8 @@ TEST_F(HttpSecurityHeadersTest, BogusHeaders) { base::Time expiry = now; bool include_subdomains = false; - EXPECT_FALSE(ParseHSTSHeader(now, "", &expiry, &include_subdomains)); + EXPECT_FALSE( + ParseHSTSHeader(now, std::string(), &expiry, &include_subdomains)); EXPECT_FALSE(ParseHSTSHeader(now, " ", &expiry, &include_subdomains)); EXPECT_FALSE(ParseHSTSHeader(now, "abc", &expiry, &include_subdomains)); EXPECT_FALSE(ParseHSTSHeader(now, " abc", &expiry, &include_subdomains)); @@ -135,7 +136,8 @@ static void TestBogusPinsHeaders(HashValueTag tag) { std::string good_pin = GetTestPin(2, tag); std::string backup_pin = GetTestPin(4, tag); - EXPECT_FALSE(ParseHPKPHeader(now, "", chain_hashes, &expiry, &hashes)); + EXPECT_FALSE( + ParseHPKPHeader(now, std::string(), chain_hashes, &expiry, &hashes)); EXPECT_FALSE(ParseHPKPHeader(now, " ", chain_hashes, &expiry, &hashes)); EXPECT_FALSE(ParseHPKPHeader(now, "abc", chain_hashes, &expiry, &hashes)); EXPECT_FALSE(ParseHPKPHeader(now, " abc", chain_hashes, &expiry, &hashes)); diff --git a/net/http/http_server_properties_impl_unittest.cc b/net/http/http_server_properties_impl_unittest.cc index 8dc9de3..b9ef0bf 100644 --- a/net/http/http_server_properties_impl_unittest.cc +++ b/net/http/http_server_properties_impl_unittest.cc @@ -65,7 +65,7 @@ TEST_F(SpdyServerPropertiesTest, Initialize) { } TEST_F(SpdyServerPropertiesTest, SupportsSpdyTest) { - HostPortPair spdy_server_empty("", 443); + HostPortPair spdy_server_empty(std::string(), 443); EXPECT_FALSE(impl_.SupportsSpdy(spdy_server_empty)); // Add www.google.com:443 as supporting SPDY. @@ -89,7 +89,7 @@ TEST_F(SpdyServerPropertiesTest, SupportsSpdyTest) { } TEST_F(SpdyServerPropertiesTest, SetSupportsSpdy) { - HostPortPair spdy_server_empty("", 443); + HostPortPair spdy_server_empty(std::string(), 443); impl_.SetSupportsSpdy(spdy_server_empty, true); EXPECT_FALSE(impl_.SupportsSpdy(spdy_server_empty)); @@ -134,7 +134,7 @@ TEST_F(SpdyServerPropertiesTest, GetSpdyServerList) { EXPECT_EQ(0U, spdy_server_list.GetSize()); // Check empty server is not added. - HostPortPair spdy_server_empty("", 443); + HostPortPair spdy_server_empty(std::string(), 443); impl_.SetSupportsSpdy(spdy_server_empty, true); impl_.GetSpdyServerList(&spdy_server_list); EXPECT_EQ(0U, spdy_server_list.GetSize()); @@ -303,7 +303,7 @@ TEST_F(SpdySettingsServerPropertiesTest, Initialize) { } TEST_F(SpdySettingsServerPropertiesTest, SetSpdySetting) { - HostPortPair spdy_server_empty("", 443); + HostPortPair spdy_server_empty(std::string(), 443); const SettingsMap& settings_map0 = impl_.GetSpdySettings(spdy_server_empty); EXPECT_EQ(0U, settings_map0.size()); // Returns kEmptySettingsMap. diff --git a/net/http/http_stream_factory_impl_unittest.cc b/net/http/http_stream_factory_impl_unittest.cc index 0a9437f..f228d9a 100644 --- a/net/http/http_stream_factory_impl_unittest.cc +++ b/net/http/http_stream_factory_impl_unittest.cc @@ -271,11 +271,24 @@ CapturePreconnectsHttpProxySocketPool::CapturePreconnectsSocketPool( : HttpProxyClientSocketPool(0, 0, NULL, host_resolver, NULL, NULL, NULL), last_num_streams_(-1) {} -template<> +template <> CapturePreconnectsSSLSocketPool::CapturePreconnectsSocketPool( - HostResolver* host_resolver, CertVerifier* cert_verifier) - : SSLClientSocketPool(0, 0, NULL, host_resolver, cert_verifier, NULL, - NULL, "", NULL, NULL, NULL, NULL, NULL, NULL), + HostResolver* host_resolver, + CertVerifier* cert_verifier) + : SSLClientSocketPool(0, + 0, + NULL, + host_resolver, + cert_verifier, + NULL, + NULL, + std::string(), + NULL, + NULL, + NULL, + NULL, + NULL, + NULL), last_num_streams_(-1) {} TEST(HttpStreamFactoryTest, PreconnectDirect) { diff --git a/net/http/http_util_unittest.cc b/net/http/http_util_unittest.cc index 083343d..f86821c 100644 --- a/net/http/http_util_unittest.cc +++ b/net/http/http_util_unittest.cc @@ -966,12 +966,12 @@ TEST(HttpUtilTest, NameValuePairsIteratorCopyAndAssign) { } TEST(HttpUtilTest, NameValuePairsIteratorEmptyInput) { - std::string data = ""; + std::string data; HttpUtil::NameValuePairsIterator parser(data.begin(), data.end(), ';'); EXPECT_TRUE(parser.valid()); - ASSERT_NO_FATAL_FAILURE( - CheckNextNameValuePair(&parser, false, true, "", "")); + ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair( + &parser, false, true, std::string(), std::string())); } TEST(HttpUtilTest, NameValuePairsIterator) { @@ -997,19 +997,19 @@ TEST(HttpUtilTest, NameValuePairsIterator) { ASSERT_NO_FATAL_FAILURE( CheckNextNameValuePair(&parser, true, true, "f", "'hello world'")); ASSERT_NO_FATAL_FAILURE( - CheckNextNameValuePair(&parser, true, true, "g", "")); + CheckNextNameValuePair(&parser, true, true, "g", std::string())); ASSERT_NO_FATAL_FAILURE( CheckNextNameValuePair(&parser, true, true, "h", "hello")); - ASSERT_NO_FATAL_FAILURE( - CheckNextNameValuePair(&parser, false, true, "", "")); + ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair( + &parser, false, true, std::string(), std::string())); } TEST(HttpUtilTest, NameValuePairsIteratorIllegalInputs) { ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", "; beta")); - ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("", "beta")); + ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair(std::string(), "beta")); ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", "; 'beta'=2")); - ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("", "'beta'=2")); + ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair(std::string(), "'beta'=2")); ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", ";beta=")); ASSERT_NO_FATAL_FAILURE(CheckInvalidNameValuePair("alpha=1", ";beta=;cappa=2")); @@ -1033,8 +1033,8 @@ TEST(HttpUtilTest, NameValuePairsIteratorExtraSeparators) { CheckNextNameValuePair(&parser, true, true, "beta", "2")); ASSERT_NO_FATAL_FAILURE( CheckNextNameValuePair(&parser, true, true, "cappa", "3")); - ASSERT_NO_FATAL_FAILURE( - CheckNextNameValuePair(&parser, false, true, "", "")); + ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair( + &parser, false, true, std::string(), std::string())); } // See comments on the implementation of NameValuePairsIterator::GetNext @@ -1046,6 +1046,6 @@ TEST(HttpUtilTest, NameValuePairsIteratorMissingEndQuote) { ASSERT_NO_FATAL_FAILURE( CheckNextNameValuePair(&parser, true, true, "name", "value")); - ASSERT_NO_FATAL_FAILURE( - CheckNextNameValuePair(&parser, false, true, "", "")); + ASSERT_NO_FATAL_FAILURE(CheckNextNameValuePair( + &parser, false, true, std::string(), std::string())); } diff --git a/net/http/http_vary_data.cc b/net/http/http_vary_data.cc index c716ca0..51b74a4 100644 --- a/net/http/http_vary_data.cc +++ b/net/http/http_vary_data.cc @@ -105,7 +105,7 @@ std::string HttpVaryData::GetRequestValue( if (request_info.extra_headers.GetHeader(request_header, &result)) return result; - return ""; + return std::string(); } // static diff --git a/net/http/http_vary_data_unittest.cc b/net/http/http_vary_data_unittest.cc index 38e4e32..93ee4f45 100644 --- a/net/http/http_vary_data_unittest.cc +++ b/net/http/http_vary_data_unittest.cc @@ -41,7 +41,7 @@ TEST(HttpVaryDataTest, IsInvalid) { for (size_t i = 0; i < arraysize(kTestResponses); ++i) { TestTransaction t; - t.Init("", kTestResponses[i]); + t.Init(std::string(), kTestResponses[i]); net::HttpVaryData v; EXPECT_FALSE(v.is_valid()); diff --git a/net/proxy/dhcp_proxy_script_fetcher.cc b/net/proxy/dhcp_proxy_script_fetcher.cc index 4771d9d..1771be0 100644 --- a/net/proxy/dhcp_proxy_script_fetcher.cc +++ b/net/proxy/dhcp_proxy_script_fetcher.cc @@ -9,7 +9,7 @@ namespace net { std::string DhcpProxyScriptFetcher::GetFetcherName() const { - return ""; + return std::string(); } DhcpProxyScriptFetcher::DhcpProxyScriptFetcher() {} diff --git a/net/proxy/proxy_resolver_v8_tracing_unittest.cc b/net/proxy/proxy_resolver_v8_tracing_unittest.cc index b5503e5..5e0e108 100644 --- a/net/proxy/proxy_resolver_v8_tracing_unittest.cc +++ b/net/proxy/proxy_resolver_v8_tracing_unittest.cc @@ -282,7 +282,8 @@ TEST_F(ProxyResolverV8TracingTest, Dns) { host_resolver.rules()->AddRuleForAddressFamily( "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44"); - host_resolver.rules()->AddIPLiteralRule("host1", "::1,192.168.1.1", ""); + host_resolver.rules() + ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string()); host_resolver.rules()->AddSimulatedFailure("host2"); host_resolver.rules()->AddRule("host3", "166.155.144.33"); host_resolver.rules()->AddRule("host5", "166.155.144.55"); @@ -995,7 +996,8 @@ TEST_F(ProxyResolverV8TracingTest, MultipleResolvers) { MockHostResolver host_resolver0; host_resolver0.rules()->AddRuleForAddressFamily( "host1", ADDRESS_FAMILY_IPV4, "166.155.144.44"); - host_resolver0.rules()->AddIPLiteralRule("host1", "::1,192.168.1.1", ""); + host_resolver0.rules() + ->AddIPLiteralRule("host1", "::1,192.168.1.1", std::string()); host_resolver0.rules()->AddSimulatedFailure("host2"); host_resolver0.rules()->AddRule("host3", "166.155.144.33"); host_resolver0.rules()->AddRule("host5", "166.155.144.55"); diff --git a/net/proxy/proxy_service_unittest.cc b/net/proxy/proxy_service_unittest.cc index ec4a0fa..53cc326 100644 --- a/net/proxy/proxy_service_unittest.cc +++ b/net/proxy/proxy_service_unittest.cc @@ -1723,7 +1723,7 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomPac) { // the script download. EXPECT_TRUE(fetcher->has_pending_request()); EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url()); - fetcher->NotifyFetchCompletion(ERR_FAILED, ""); + fetcher->NotifyFetchCompletion(ERR_FAILED, std::string()); // Next it should be trying the custom PAC url. EXPECT_TRUE(fetcher->has_pending_request()); @@ -1872,12 +1872,12 @@ TEST_F(ProxyServiceTest, FallbackFromAutodetectToCustomToManual) { // It should be trying to auto-detect first -- fail the download. EXPECT_TRUE(fetcher->has_pending_request()); EXPECT_EQ(GURL("http://wpad/wpad.dat"), fetcher->pending_request_url()); - fetcher->NotifyFetchCompletion(ERR_FAILED, ""); + fetcher->NotifyFetchCompletion(ERR_FAILED, std::string()); // Next it should be trying the custom PAC url -- fail the download. EXPECT_TRUE(fetcher->has_pending_request()); EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url()); - fetcher->NotifyFetchCompletion(ERR_FAILED, ""); + fetcher->NotifyFetchCompletion(ERR_FAILED, std::string()); // Since we never managed to initialize a ProxyResolver, nothing should have // been sent to it. @@ -2251,7 +2251,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterFailure) { // // We simulate a failed download attempt, the proxy service should now // fall-back to DIRECT connections. - fetcher->NotifyFetchCompletion(ERR_FAILED, ""); + fetcher->NotifyFetchCompletion(ERR_FAILED, std::string()); ASSERT_TRUE(resolver->pending_requests().empty()); @@ -2604,7 +2604,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterSuccess) { // to download the script. EXPECT_TRUE(fetcher->has_pending_request()); EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url()); - fetcher->NotifyFetchCompletion(ERR_FAILED, ""); + fetcher->NotifyFetchCompletion(ERR_FAILED, std::string()); MessageLoop::current()->RunUntilIdle(); @@ -2771,7 +2771,7 @@ TEST_F(ProxyServiceTest, PACScriptRefetchAfterActivity) { EXPECT_EQ(GURL("http://foopy/proxy.pac"), fetcher->pending_request_url()); // This time we will fail the download, to simulate a PAC script change. - fetcher->NotifyFetchCompletion(ERR_FAILED, ""); + fetcher->NotifyFetchCompletion(ERR_FAILED, std::string()); // Drain the message loop, so ProxyService is notified of the change // and has a chance to re-configure itself. diff --git a/net/quic/quic_http_stream_test.cc b/net/quic/quic_http_stream_test.cc index f3f4c33..1370ced 100644 --- a/net/quic/quic_http_stream_test.cc +++ b/net/quic/quic_http_stream_test.cc @@ -348,7 +348,7 @@ TEST_F(QuicHttpStreamTest, GetRequest) { stream_->ReadResponseHeaders(callback_.callback())); // Send the response without a body. - SetResponseString("404 Not Found", ""); + SetResponseString("404 Not Found", std::string()); scoped_ptr<QuicEncryptedPacket> resp( ConstructDataPacket(2, false, kFin, 0, response_data_)); ProcessPacket(*resp); @@ -440,7 +440,7 @@ TEST_F(QuicHttpStreamTest, SendPostRequest) { ProcessPacket(*ack); // Send the response headers (but not the body). - SetResponseString("200 OK", ""); + SetResponseString("200 OK", std::string()); scoped_ptr<QuicEncryptedPacket> resp( ConstructDataPacket(2, false, !kFin, 0, response_data_)); ProcessPacket(*resp); @@ -502,7 +502,7 @@ TEST_F(QuicHttpStreamTest, SendChunkedPostRequest) { ProcessPacket(*ack); // Send the response headers (but not the body). - SetResponseString("200 OK", ""); + SetResponseString("200 OK", std::string()); scoped_ptr<QuicEncryptedPacket> resp( ConstructDataPacket(2, false, !kFin, 0, response_data_)); ProcessPacket(*resp); diff --git a/net/quic/quic_packet_creator_test.cc b/net/quic/quic_packet_creator_test.cc index 5e7ed61..2f4e2e9 100644 --- a/net/quic/quic_packet_creator_test.cc +++ b/net/quic/quic_packet_creator_test.cc @@ -180,7 +180,7 @@ TEST_F(QuicPacketCreatorTest, CreateStreamFrameFinOnly) { QuicFrame frame; size_t consumed = creator_.CreateStreamFrame(1u, "", 0u, true, &frame); EXPECT_EQ(0u, consumed); - CheckStreamFrame(frame, 1u, "", 0u, true); + CheckStreamFrame(frame, 1u, std::string(), 0u, true); delete frame.stream_frame; } diff --git a/net/quic/quic_packet_generator_test.cc b/net/quic/quic_packet_generator_test.cc index c7e2918..4e84d0b 100644 --- a/net/quic/quic_packet_generator_test.cc +++ b/net/quic/quic_packet_generator_test.cc @@ -120,7 +120,7 @@ class QuicPacketGeneratorTest : public ::testing::Test { } QuicGoAwayFrame* CreateGoAwayFrame() { - return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, ""); + return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, std::string()); } void CheckPacketContains(const PacketContents& contents, diff --git a/net/server/http_server.cc b/net/server/http_server.cc index 4f1fb08..a0c9a3a 100644 --- a/net/server/http_server.cc +++ b/net/server/http_server.cc @@ -62,7 +62,7 @@ void HttpServer::Send200(int connection_id, } void HttpServer::Send404(int connection_id) { - Send(connection_id, HTTP_NOT_FOUND, "", "text/html"); + Send(connection_id, HTTP_NOT_FOUND, std::string(), "text/html"); } void HttpServer::Send500(int connection_id, const std::string& message) { diff --git a/net/server/http_server_request_info.cc b/net/server/http_server_request_info.cc index eda597a..08b925f 100644 --- a/net/server/http_server_request_info.cc +++ b/net/server/http_server_request_info.cc @@ -16,7 +16,7 @@ std::string HttpServerRequestInfo::GetHeaderValue( headers.find(header_name); if (it != headers.end()) return it->second; - return ""; + return std::string(); } } // namespace net diff --git a/net/socket/client_socket_pool_base_unittest.cc b/net/socket/client_socket_pool_base_unittest.cc index 0628d91..bc64306 100644 --- a/net/socket/client_socket_pool_base_unittest.cc +++ b/net/socket/client_socket_pool_base_unittest.cc @@ -274,7 +274,7 @@ class TestConnectJob : public ConnectJob { // Set all of the additional error state fields in some way. handle->set_is_ssl_error(true); HttpResponseInfo info; - info.headers = new HttpResponseHeaders(""); + info.headers = new HttpResponseHeaders(std::string()); handle->set_ssl_error_response_info(info); } } @@ -846,7 +846,7 @@ TEST_F(ClientSocketPoolBaseTest, InitConnectionFailure) { // Set the additional error state members to ensure that they get cleared. handle.set_is_ssl_error(true); HttpResponseInfo info; - info.headers = new HttpResponseHeaders(""); + info.headers = new HttpResponseHeaders(std::string()); handle.set_ssl_error_response_info(info); EXPECT_EQ(ERR_CONNECTION_FAILED, handle.Init("a", @@ -1720,7 +1720,7 @@ TEST_F(ClientSocketPoolBaseTest, // Set the additional error state members to ensure that they get cleared. handle.set_is_ssl_error(true); HttpResponseInfo info; - info.headers = new HttpResponseHeaders(""); + info.headers = new HttpResponseHeaders(std::string()); handle.set_ssl_error_response_info(info); EXPECT_EQ(ERR_IO_PENDING, handle.Init("a", params_, diff --git a/net/socket/deterministic_socket_data_unittest.cc b/net/socket/deterministic_socket_data_unittest.cc index a007e36..aea8160 100644 --- a/net/socket/deterministic_socket_data_unittest.cc +++ b/net/socket/deterministic_socket_data_unittest.cc @@ -77,9 +77,8 @@ DeterministicSocketDataTest::DeterministicSocketDataTest() false, false, OnHostResolutionCallback())), - histograms_(""), - socket_pool_(10, 10, &histograms_, &socket_factory_) { -} + histograms_(std::string()), + socket_pool_(10, 10, &histograms_, &socket_factory_) {} void DeterministicSocketDataTest::TearDown() { // Empty the current queue. diff --git a/net/socket/ssl_client_socket_pool_unittest.cc b/net/socket/ssl_client_socket_pool_unittest.cc index c188a80..fe7e3d2 100644 --- a/net/socket/ssl_client_socket_pool_unittest.cc +++ b/net/socket/ssl_client_socket_pool_unittest.cc @@ -79,46 +79,54 @@ class SSLClientSocketPoolTest : public testing::Test { SSLClientSocketPoolTest() : proxy_service_(ProxyService::CreateDirect()), ssl_config_service_(new SSLConfigServiceDefaults), - http_auth_handler_factory_(HttpAuthHandlerFactory::CreateDefault( - &host_resolver_)), + http_auth_handler_factory_( + HttpAuthHandlerFactory::CreateDefault(&host_resolver_)), session_(CreateNetworkSession()), - direct_transport_socket_params_(new TransportSocketParams( - HostPortPair("host", 443), MEDIUM, false, false, - OnHostResolutionCallback())), + direct_transport_socket_params_( + new TransportSocketParams(HostPortPair("host", 443), + MEDIUM, + false, + false, + OnHostResolutionCallback())), transport_histograms_("MockTCP"), - transport_socket_pool_( - kMaxSockets, - kMaxSocketsPerGroup, - &transport_histograms_, - &socket_factory_), - proxy_transport_socket_params_(new TransportSocketParams( - HostPortPair("proxy", 443), MEDIUM, false, false, - OnHostResolutionCallback())), - socks_socket_params_(new SOCKSSocketParams( - proxy_transport_socket_params_, true, - HostPortPair("sockshost", 443), MEDIUM)), + transport_socket_pool_(kMaxSockets, + kMaxSocketsPerGroup, + &transport_histograms_, + &socket_factory_), + proxy_transport_socket_params_( + new TransportSocketParams(HostPortPair("proxy", 443), + MEDIUM, + false, + false, + OnHostResolutionCallback())), + socks_socket_params_( + new SOCKSSocketParams(proxy_transport_socket_params_, + true, + HostPortPair("sockshost", 443), + MEDIUM)), socks_histograms_("MockSOCKS"), - socks_socket_pool_( - kMaxSockets, - kMaxSocketsPerGroup, - &socks_histograms_, - &transport_socket_pool_), - http_proxy_socket_params_(new HttpProxySocketParams( - proxy_transport_socket_params_, NULL, GURL("http://host"), "", - HostPortPair("host", 80), - session_->http_auth_cache(), - session_->http_auth_handler_factory(), - session_->spdy_session_pool(), - true)), + socks_socket_pool_(kMaxSockets, + kMaxSocketsPerGroup, + &socks_histograms_, + &transport_socket_pool_), + http_proxy_socket_params_( + new HttpProxySocketParams(proxy_transport_socket_params_, + NULL, + GURL("http://host"), + std::string(), + HostPortPair("host", 80), + session_->http_auth_cache(), + session_->http_auth_handler_factory(), + session_->spdy_session_pool(), + true)), http_proxy_histograms_("MockHttpProxy"), - http_proxy_socket_pool_( - kMaxSockets, - kMaxSocketsPerGroup, - &http_proxy_histograms_, - &host_resolver_, - &transport_socket_pool_, - NULL, - NULL) { + http_proxy_socket_pool_(kMaxSockets, + kMaxSocketsPerGroup, + &http_proxy_histograms_, + &host_resolver_, + &transport_socket_pool_, + NULL, + NULL) { scoped_refptr<SSLConfigService> ssl_config_service( new SSLConfigServiceDefaults); ssl_config_service->GetSSLConfig(&ssl_config_); @@ -134,7 +142,7 @@ class SSLClientSocketPoolTest : public testing::Test { NULL /* cert_verifier */, NULL /* server_bound_cert_service */, NULL /* transport_security_state */, - "" /* ssl_session_cache_shard */, + std::string() /* ssl_session_cache_shard */, &socket_factory_, transport_pool ? &transport_socket_pool_ : NULL, socks_pool ? &socks_socket_pool_ : NULL, @@ -722,8 +730,8 @@ TEST_F(SSLClientSocketPoolTest, IPPooling) { host_resolver_.set_synchronous_mode(true); for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { - host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name, - test_hosts[i].iplist, ""); + host_resolver_.rules()->AddIPLiteralRule( + test_hosts[i].name, test_hosts[i].iplist, std::string()); // This test requires that the HostResolver cache be populated. Normal // code would have done this already, but we do it manually. @@ -805,8 +813,8 @@ void SSLClientSocketPoolTest::TestIPPoolingDisabled( TestCompletionCallback callback; int rv; for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { - host_resolver_.rules()->AddIPLiteralRule(test_hosts[i].name, - test_hosts[i].iplist, ""); + host_resolver_.rules()->AddIPLiteralRule( + test_hosts[i].name, test_hosts[i].iplist, std::string()); // This test requires that the HostResolver cache be populated. Normal // code would have done this already, but we do it manually. diff --git a/net/socket/transport_client_socket_pool_unittest.cc b/net/socket/transport_client_socket_pool_unittest.cc index eba7c26..9d95a1b 100644 --- a/net/socket/transport_client_socket_pool_unittest.cc +++ b/net/socket/transport_client_socket_pool_unittest.cc @@ -1210,8 +1210,8 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv4FinishesFirst) { client_socket_factory_.set_client_socket_types(case_types, 2); // Resolve an AddressList with a IPv6 address first and then a IPv4 address. - host_resolver_->rules()->AddIPLiteralRule( - "*", "2:abcd::3:4:ff,2.2.2.2", ""); + host_resolver_->rules() + ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); TestCompletionCallback callback; ClientSocketHandle handle; @@ -1255,8 +1255,8 @@ TEST_F(TransportClientSocketPoolTest, IPv6FallbackSocketIPv6FinishesFirst) { TransportConnectJob::kIPv6FallbackTimerInMs + 50)); // Resolve an AddressList with a IPv6 address first and then a IPv4 address. - host_resolver_->rules()->AddIPLiteralRule( - "*", "2:abcd::3:4:ff,2.2.2.2", ""); + host_resolver_->rules() + ->AddIPLiteralRule("*", "2:abcd::3:4:ff,2.2.2.2", std::string()); TestCompletionCallback callback; ClientSocketHandle handle; @@ -1289,8 +1289,8 @@ TEST_F(TransportClientSocketPoolTest, IPv6NoIPv4AddressesToFallbackTo) { MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); // Resolve an AddressList with only IPv6 addresses. - host_resolver_->rules()->AddIPLiteralRule( - "*", "2:abcd::3:4:ff,3:abcd::3:4:ff", ""); + host_resolver_->rules() + ->AddIPLiteralRule("*", "2:abcd::3:4:ff,3:abcd::3:4:ff", std::string()); TestCompletionCallback callback; ClientSocketHandle handle; @@ -1323,8 +1323,7 @@ TEST_F(TransportClientSocketPoolTest, IPv4HasNoFallback) { MockClientSocketFactory::MOCK_DELAYED_CLIENT_SOCKET); // Resolve an AddressList with only IPv4 addresses. - host_resolver_->rules()->AddIPLiteralRule( - "*", "1.1.1.1", ""); + host_resolver_->rules()->AddIPLiteralRule("*", "1.1.1.1", std::string()); TestCompletionCallback callback; ClientSocketHandle handle; diff --git a/net/spdy/spdy_framer_test.cc b/net/spdy/spdy_framer_test.cc index 46d44c9..3ae8871a 100644 --- a/net/spdy/spdy_framer_test.cc +++ b/net/spdy/spdy_framer_test.cc @@ -1826,7 +1826,7 @@ TEST_P(SpdyFramerTest, CreateSynStreamUncompressed) { "max stream ID"; SpdyHeaderBlock headers; - headers[""] = "foo"; + headers[std::string()] = "foo"; headers["foo"] = "bar"; const unsigned char kV2FrameData[] = { @@ -2103,7 +2103,7 @@ TEST_P(SpdyFramerTest, CreateSynReplyUncompressed) { "SYN_REPLY frame with a 0-length header name, FIN, max stream ID"; SpdyHeaderBlock headers; - headers[""] = "foo"; + headers[std::string()] = "foo"; headers["foo"] = "bar"; const unsigned char kV2FrameData[] = { @@ -2619,7 +2619,7 @@ TEST_P(SpdyFramerTest, CreateHeadersUncompressed) { "HEADERS frame with a 0-length header name, FIN, max stream ID"; SpdyHeaderBlock headers; - headers[""] = "foo"; + headers[std::string()] = "foo"; headers["foo"] = "bar"; const unsigned char kV2FrameData[] = { diff --git a/net/spdy/spdy_http_utils.cc b/net/spdy/spdy_http_utils.cc index 41647c1..49fb8ca 100644 --- a/net/spdy/spdy_http_utils.cc +++ b/net/spdy/spdy_http_utils.cc @@ -188,8 +188,9 @@ GURL GetUrlFromHeaderBlock(const SpdyHeaderBlock& headers, if (it != headers.end()) path = it->second; - std::string url = (scheme.empty() || host_port.empty() || path.empty()) - ? "" : scheme + "://" + host_port + path; + std::string url = (scheme.empty() || host_port.empty() || path.empty()) + ? std::string() + : scheme + "://" + host_port + path; return GURL(url); } diff --git a/net/spdy/spdy_session_spdy2_unittest.cc b/net/spdy/spdy_session_spdy2_unittest.cc index 0b93815..1d7026f 100644 --- a/net/spdy/spdy_session_spdy2_unittest.cc +++ b/net/spdy/spdy_session_spdy2_unittest.cc @@ -678,8 +678,8 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) { SpdySessionDependencies session_deps; session_deps.host_resolver->set_synchronous_mode(true); for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { - session_deps.host_resolver->rules()->AddIPLiteralRule(test_hosts[i].name, - test_hosts[i].iplist, ""); + session_deps.host_resolver->rules()->AddIPLiteralRule( + test_hosts[i].name, test_hosts[i].iplist, std::string()); // This test requires that the HostResolver cache be populated. Normal // code would have done this already, but we do it manually. @@ -1139,7 +1139,7 @@ TEST_F(SpdySessionSpdy2Test, CloseSessionWithTwoCreatedStreams) { EXPECT_EQ(0u, spdy_stream2->stream_id()); // Ensure we don't crash while closing the session. - session->CloseSessionOnError(ERR_ABORTED, true, ""); + session->CloseSessionOnError(ERR_ABORTED, true, std::string()); EXPECT_TRUE(spdy_stream1->closed()); EXPECT_TRUE(spdy_stream2->closed()); diff --git a/net/spdy/spdy_session_spdy3_unittest.cc b/net/spdy/spdy_session_spdy3_unittest.cc index c790251..eaf23ffe 100644 --- a/net/spdy/spdy_session_spdy3_unittest.cc +++ b/net/spdy/spdy_session_spdy3_unittest.cc @@ -704,8 +704,8 @@ void IPPoolingTest(SpdyPoolCloseSessionsType close_sessions_type) { SpdySessionDependencies session_deps; session_deps.host_resolver->set_synchronous_mode(true); for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_hosts); i++) { - session_deps.host_resolver->rules()->AddIPLiteralRule(test_hosts[i].name, - test_hosts[i].iplist, ""); + session_deps.host_resolver->rules()->AddIPLiteralRule( + test_hosts[i].name, test_hosts[i].iplist, std::string()); // This test requires that the HostResolver cache be populated. Normal // code would have done this already, but we do it manually. @@ -1140,7 +1140,7 @@ TEST_F(SpdySessionSpdy3Test, CloseSessionWithTwoCreatedStreams) { EXPECT_EQ(0u, spdy_stream2->stream_id()); // Ensure we don't crash while closing the session. - session->CloseSessionOnError(ERR_ABORTED, true, ""); + session->CloseSessionOnError(ERR_ABORTED, true, std::string()); EXPECT_TRUE(spdy_stream1->closed()); EXPECT_TRUE(spdy_stream2->closed()); diff --git a/net/spdy/spdy_stream.cc b/net/spdy/spdy_stream.cc index 5725253..70412dd 100644 --- a/net/spdy/spdy_stream.cc +++ b/net/spdy/spdy_stream.cc @@ -534,7 +534,7 @@ void SpdyStream::Cancel() { cancelled_ = true; if (session_->IsStreamActive(stream_id_)) - session_->ResetStream(stream_id_, RST_STREAM_CANCEL, ""); + session_->ResetStream(stream_id_, RST_STREAM_CANCEL, std::string()); else if (stream_id_ == 0) session_->CloseCreatedStream(this, RST_STREAM_CANCEL); } diff --git a/net/spdy/spdy_stream_test_util.cc b/net/spdy/spdy_stream_test_util.cc index 3b2235f..00a58df 100644 --- a/net/spdy/spdy_stream_test_util.cc +++ b/net/spdy/spdy_stream_test_util.cc @@ -101,7 +101,7 @@ int StreamDelegateBase::WaitForClose() { std::string StreamDelegateBase::GetResponseHeaderValue( const std::string& name) const { SpdyHeaderBlock::const_iterator it = response_.find(name); - return (it == response_.end()) ? "" : it->second; + return (it == response_.end()) ? std::string() : it->second; } StreamDelegateSendImmediate::StreamDelegateSendImmediate( diff --git a/net/spdy/spdy_write_queue_unittest.cc b/net/spdy/spdy_write_queue_unittest.cc index c295db8..26029e4 100644 --- a/net/spdy/spdy_write_queue_unittest.cc +++ b/net/spdy/spdy_write_queue_unittest.cc @@ -60,7 +60,8 @@ int ProducerToInt(scoped_ptr<SpdyFrameProducer> producer) { // -- be careful to not call any functions that expect the session to // be there. SpdyStream* MakeTestStream(RequestPriority priority) { - return new SpdyStream(NULL, "", priority, 0, 0, false, BoundNetLog()); + return new SpdyStream( + NULL, std::string(), priority, 0, 0, false, BoundNetLog()); } // Add some frame producers of different priority. The producers diff --git a/net/ssl/server_bound_cert_service.cc b/net/ssl/server_bound_cert_service.cc index bed97cf..3a50ed6 100644 --- a/net/ssl/server_bound_cert_service.cc +++ b/net/ssl/server_bound_cert_service.cc @@ -579,8 +579,11 @@ void ServerBoundCertService::GotServerBoundCert( delete worker; // TODO(rkn): Log to the NetLog. LOG(ERROR) << "ServerBoundCertServiceWorker couldn't be started."; - HandleResult(ERR_INSUFFICIENT_RESOURCES, server_identifier, - CLIENT_CERT_INVALID_TYPE, "", ""); + HandleResult(ERR_INSUFFICIENT_RESOURCES, + server_identifier, + CLIENT_CERT_INVALID_TYPE, + std::string(), + std::string()); return; } } @@ -610,7 +613,11 @@ void ServerBoundCertService::GeneratedServerBoundCert( HandleResult(error, server_identifier, cert->type(), cert->private_key(), cert->cert()); } else { - HandleResult(error, server_identifier, CLIENT_CERT_INVALID_TYPE, "", ""); + HandleResult(error, + server_identifier, + CLIENT_CERT_INVALID_TYPE, + std::string(), + std::string()); } } diff --git a/net/test/base_test_server.cc b/net/test/base_test_server.cc index 3a2dc11..ab9b121 100644 --- a/net/test/base_test_server.cc +++ b/net/test/base_test_server.cc @@ -92,7 +92,7 @@ base::FilePath BaseTestServer::SSLOptions::GetCertificateFile() const { std::string BaseTestServer::SSLOptions::GetOCSPArgument() const { if (server_certificate != CERT_AUTO) - return ""; + return std::string(); switch (ocsp_status) { case OCSP_OK: @@ -107,7 +107,7 @@ std::string BaseTestServer::SSLOptions::GetOCSPArgument() const { return "unknown"; default: NOTREACHED(); - return ""; + return std::string(); } } diff --git a/net/tools/dump_cache/url_to_filename_encoder_unittest.cc b/net/tools/dump_cache/url_to_filename_encoder_unittest.cc index 2e09e0b..23bbc6d 100644 --- a/net/tools/dump_cache/url_to_filename_encoder_unittest.cc +++ b/net/tools/dump_cache/url_to_filename_encoder_unittest.cc @@ -57,7 +57,8 @@ class UrlToFilenameEncoderTest : public ::testing::Test { void Validate(const string& in_word, const string& gold_word) { string escaped_word, url; - UrlToFilenameEncoder::EncodeSegment("", in_word, '/', &escaped_word); + UrlToFilenameEncoder::EncodeSegment( + std::string(), in_word, '/', &escaped_word); EXPECT_EQ(gold_word, escaped_word); CheckSegmentLength(escaped_word); CheckValidChars(escaped_word, '\\'); @@ -67,7 +68,8 @@ class UrlToFilenameEncoderTest : public ::testing::Test { void ValidateAllSegmentsSmall(const string& in_word) { string escaped_word, url; - UrlToFilenameEncoder::EncodeSegment("", in_word, '/', &escaped_word); + UrlToFilenameEncoder::EncodeSegment( + std::string(), in_word, '/', &escaped_word); CheckSegmentLength(escaped_word); CheckValidChars(escaped_word, '\\'); UrlToFilenameEncoder::Decode(escaped_word, '/', &url); @@ -106,13 +108,13 @@ class UrlToFilenameEncoderTest : public ::testing::Test { void ValidateUrlOldNew(const string& url, const string& gold_old_filename, const string& gold_new_filename) { - ValidateUrl(url, "", true, gold_old_filename); - ValidateUrl(url, "", false, gold_new_filename); + ValidateUrl(url, std::string(), true, gold_old_filename); + ValidateUrl(url, std::string(), false, gold_new_filename); } void ValidateEncodeSame(const string& url1, const string& url2) { - string filename1 = UrlToFilenameEncoder::Encode(url1, "", false); - string filename2 = UrlToFilenameEncoder::Encode(url2, "", false); + string filename1 = UrlToFilenameEncoder::Encode(url1, std::string(), false); + string filename2 = UrlToFilenameEncoder::Encode(url2, std::string(), false); EXPECT_EQ(filename1, filename2); } @@ -121,7 +123,7 @@ class UrlToFilenameEncoderTest : public ::testing::Test { }; TEST_F(UrlToFilenameEncoderTest, DoesNotEscape) { - ValidateNoChange(""); + ValidateNoChange(std::string()); ValidateNoChange("abcdefg"); ValidateNoChange("abcdefghijklmnopqrstuvwxyz"); ValidateNoChange("ZYXWVUT"); @@ -193,7 +195,8 @@ TEST_F(UrlToFilenameEncoderTest, EncodeUrlCorrectly) { // From bug: Double slash preserved. ValidateUrl("http://www.foo.com/u?site=http://www.google.com/index.html", - "", false, + std::string(), + false, "www.foo.com" + dir_sep_ + "u" + escape_ + "3Fsite=http" + escape_ + "3A" + dir_sep_ + escape_ + "2Fwww.google.com" + dir_sep_ + "index.html" + escape_); @@ -326,7 +329,8 @@ TEST_F(UrlToFilenameEncoderTest, BackslashSeparator) { string long_word; string escaped_word; long_word.append(UrlToFilenameEncoder::kMaximumSubdirectoryLength + 1, 'x'); - UrlToFilenameEncoder::EncodeSegment("", long_word, '\\', &escaped_word); + UrlToFilenameEncoder::EncodeSegment( + std::string(), long_word, '\\', &escaped_word); // check that one backslash, plus the escape ",-", and the ending , got added. EXPECT_EQ(long_word.size() + 4, escaped_word.size()); diff --git a/net/tools/fetch/fetch_server.cc b/net/tools/fetch/fetch_server.cc index 830cd18..34c7c83 100644 --- a/net/tools/fetch/fetch_server.cc +++ b/net/tools/fetch/fetch_server.cc @@ -36,7 +36,8 @@ int main(int argc, char**argv) { // Do work here. MessageLoop loop; - HttpServer server("", 80); // TODO(mbelshe): make port configurable + HttpServer server(std::string(), + 80); // TODO(mbelshe): make port configurable MessageLoop::current()->Run(); if (parsed_command_line.HasSwitch("stats")) { diff --git a/net/tools/flip_server/acceptor_thread.cc b/net/tools/flip_server/acceptor_thread.cc index b16d181..ed8a3ec 100644 --- a/net/tools/flip_server/acceptor_thread.cc +++ b/net/tools/flip_server/acceptor_thread.cc @@ -105,7 +105,9 @@ void SMAcceptorThread::HandleConnection(int server_fd, NULL, &epoll_server_, server_fd, - "", "", remote_ip, + std::string(), + std::string(), + remote_ip, use_ssl_); if (server_connection->initialized()) active_server_connections_.push_back(server_connection); diff --git a/net/tools/flip_server/flip_in_mem_edsm_server.cc b/net/tools/flip_server/flip_in_mem_edsm_server.cc index 8ba1505..15fb9644 100644 --- a/net/tools/flip_server/flip_in_mem_edsm_server.cc +++ b/net/tools/flip_server/flip_in_mem_edsm_server.cc @@ -335,11 +335,16 @@ int main (int argc, char**argv) std::string value = cl.GetSwitchValueASCII("spdy-server"); std::vector<std::string> valueArgs = split(value, ','); while (valueArgs.size() < 4) - valueArgs.push_back(""); + valueArgs.push_back(std::string()); g_proxy_config.AddAcceptor(net::FLIP_HANDLER_SPDY_SERVER, - valueArgs[0], valueArgs[1], - valueArgs[2], valueArgs[3], - "", "", "", "", + valueArgs[0], + valueArgs[1], + valueArgs[2], + valueArgs[3], + std::string(), + std::string(), + std::string(), + std::string(), 0, FLAGS_accept_backlog_size, FLAGS_disable_nagle, @@ -356,11 +361,16 @@ int main (int argc, char**argv) std::string value = cl.GetSwitchValueASCII("http-server"); std::vector<std::string> valueArgs = split(value, ','); while (valueArgs.size() < 4) - valueArgs.push_back(""); + valueArgs.push_back(std::string()); g_proxy_config.AddAcceptor(net::FLIP_HANDLER_HTTP_SERVER, - valueArgs[0], valueArgs[1], - valueArgs[2], valueArgs[3], - "", "", "", "", + valueArgs[0], + valueArgs[1], + valueArgs[2], + valueArgs[3], + std::string(), + std::string(), + std::string(), + std::string(), 0, FLAGS_accept_backlog_size, FLAGS_disable_nagle, diff --git a/net/tools/flip_server/spdy_interface.cc b/net/tools/flip_server/spdy_interface.cc index 1c34e79..649e99e 100644 --- a/net/tools/flip_server/spdy_interface.cc +++ b/net/tools/flip_server/spdy_interface.cc @@ -112,9 +112,14 @@ SMInterface* SpdySM::FindOrMakeNewSMConnectionInterface( } sm_http_interface->InitSMInterface(this, server_idx); - sm_http_interface->InitSMConnection(NULL, sm_http_interface, - epoll_server_, -1, - server_ip, server_port, "", false); + sm_http_interface->InitSMConnection(NULL, + sm_http_interface, + epoll_server_, + -1, + server_ip, + server_port, + std::string(), + false); return sm_http_interface; } diff --git a/net/tools/flip_server/streamer_interface.cc b/net/tools/flip_server/streamer_interface.cc index 9e6e6c8..b1612e7 100644 --- a/net/tools/flip_server/streamer_interface.cc +++ b/net/tools/flip_server/streamer_interface.cc @@ -131,11 +131,13 @@ int StreamerSM::PostAcceptHook() { } // The Streamer interface is used to stream HTTPS connections, so we // will always use the https_server_ip/port here. - sm_other_interface_->InitSMConnection(NULL, sm_other_interface_, - epoll_server_, -1, + sm_other_interface_->InitSMConnection(NULL, + sm_other_interface_, + epoll_server_, + -1, acceptor_->https_server_ip_, acceptor_->https_server_port_, - "", + std::string(), false); return 1; diff --git a/net/tools/quic/end_to_end_test.cc b/net/tools/quic/end_to_end_test.cc index e98c4ea..cb14db8 100644 --- a/net/tools/quic/end_to_end_test.cc +++ b/net/tools/quic/end_to_end_test.cc @@ -234,7 +234,7 @@ TEST_F(EndToEndTest, SeparateFinPacket) { client_->SendMessage(request); - client_->SendData("", true); + client_->SendData(std::string(), true); client_->WaitForResponse(); EXPECT_EQ(kFooResponseBody, client_->response_body()); @@ -243,7 +243,7 @@ TEST_F(EndToEndTest, SeparateFinPacket) { request.AddBody("foo", true); client_->SendMessage(request); - client_->SendData("", true); + client_->SendData(std::string(), true); client_->WaitForResponse(); EXPECT_EQ(kFooResponseBody, client_->response_body()); EXPECT_EQ(200ul, client_->response_headers()->parsed_response_code()); diff --git a/net/tools/quic/quic_client.cc b/net/tools/quic/quic_client.cc index 4a61ab4..8acb85a 100644 --- a/net/tools/quic/quic_client.cc +++ b/net/tools/quic/quic_client.cc @@ -43,8 +43,8 @@ QuicClient::QuicClient(IPEndPoint server_address, QuicClient::~QuicClient() { if (connected()) { - session()->connection()->SendConnectionClosePacket( - QUIC_PEER_GOING_AWAY, ""); + session()->connection() + ->SendConnectionClosePacket(QUIC_PEER_GOING_AWAY, std::string()); } } diff --git a/net/tools/quic/test_tools/quic_test_client.cc b/net/tools/quic/test_tools/quic_test_client.cc index 53bc057..843af2f 100644 --- a/net/tools/quic/test_tools/quic_test_client.cc +++ b/net/tools/quic/test_tools/quic_test_client.cc @@ -85,7 +85,7 @@ string QuicTestClient::SendCustomSynchronousRequest( string QuicTestClient::SendSynchronousRequest(const string& uri) { if (SendRequest(uri) == 0) { DLOG(ERROR) << "Failed to the request for uri:" << uri; - return ""; + return std::string(); } WaitForResponse(); return response_; diff --git a/net/udp/udp_socket_unittest.cc b/net/udp/udp_socket_unittest.cc index c2085ad..09a2806 100644 --- a/net/udp/udp_socket_unittest.cc +++ b/net/udp/udp_socket_unittest.cc @@ -38,7 +38,7 @@ class UDPSocketTest : public PlatformTest { if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); if (rv < 0) - return ""; // error! + return std::string(); // error! return std::string(buffer_->data(), rv); } @@ -82,7 +82,7 @@ class UDPSocketTest : public PlatformTest { if (rv == ERR_IO_PENDING) rv = callback.WaitForResult(); if (rv < 0) - return ""; // error! + return std::string(); // error! return std::string(buffer_->data(), rv); } diff --git a/net/url_request/url_fetcher_impl_unittest.cc b/net/url_request/url_fetcher_impl_unittest.cc index 98a3a11..c8cbd1a 100644 --- a/net/url_request/url_fetcher_impl_unittest.cc +++ b/net/url_request/url_fetcher_impl_unittest.cc @@ -441,11 +441,16 @@ class CancelTestURLRequestContextGetter // The initial backoff is 2 seconds and maximum backoff is 4 seconds. // Maximum retries allowed is set to 2. scoped_refptr<URLRequestThrottlerEntry> entry( - new URLRequestThrottlerEntry( - context_->throttler_manager(), - "", 200, 3, 2000, 2.0, 0.0, 4000)); - context_->throttler_manager()->OverrideEntryForTests( - throttle_for_url_, entry); + new URLRequestThrottlerEntry(context_->throttler_manager(), + std::string(), + 200, + 3, + 2000, + 2.0, + 0.0, + 4000)); + context_->throttler_manager() + ->OverrideEntryForTests(throttle_for_url_, entry); context_created_.Signal(); } @@ -553,7 +558,7 @@ void URLFetcherEmptyPostTest::CreateFetcher(const GURL& url) { fetcher_ = new URLFetcherImpl(url, URLFetcher::POST, this); fetcher_->SetRequestContext(new TestURLRequestContextGetter( io_message_loop_proxy())); - fetcher_->SetUploadData("text/plain", ""); + fetcher_->SetUploadData("text/plain", std::string()); fetcher_->Start(); } @@ -1163,9 +1168,14 @@ TEST_F(URLFetcherProtectTest, Overload) { // Registers an entry for test url. It only allows 3 requests to be sent // in 200 milliseconds. scoped_refptr<URLRequestThrottlerEntry> entry( - new URLRequestThrottlerEntry( - request_context()->throttler_manager(), - "", 200, 3, 1, 2.0, 0.0, 256)); + new URLRequestThrottlerEntry(request_context()->throttler_manager(), + std::string(), + 200, + 3, + 1, + 2.0, + 0.0, + 256)); request_context()->throttler_manager()->OverrideEntryForTests(url, entry); CreateFetcher(url); @@ -1186,9 +1196,14 @@ TEST_F(URLFetcherProtectTest, ServerUnavailable) { // and maximum backoff time is 256 milliseconds. // Maximum retries allowed is set to 11. scoped_refptr<URLRequestThrottlerEntry> entry( - new URLRequestThrottlerEntry( - request_context()->throttler_manager(), - "", 200, 3, 1, 2.0, 0.0, 256)); + new URLRequestThrottlerEntry(request_context()->throttler_manager(), + std::string(), + 200, + 3, + 1, + 2.0, + 0.0, + 256)); request_context()->throttler_manager()->OverrideEntryForTests(url, entry); CreateFetcher(url); @@ -1209,9 +1224,14 @@ TEST_F(URLFetcherProtectTestPassedThrough, ServerUnavailablePropagateResponse) { // and maximum backoff time is 150000 milliseconds. // Maximum retries allowed is set to 11. scoped_refptr<URLRequestThrottlerEntry> entry( - new URLRequestThrottlerEntry( - request_context()->throttler_manager(), - "", 200, 3, 100, 2.0, 0.0, 150000)); + new URLRequestThrottlerEntry(request_context()->throttler_manager(), + std::string(), + 200, + 3, + 100, + 2.0, + 0.0, + 150000)); // Total time if *not* for not doing automatic backoff would be 150s. // In reality it should be "as soon as server responds". request_context()->throttler_manager()->OverrideEntryForTests(url, entry); @@ -1268,9 +1288,14 @@ TEST_F(URLFetcherCancelTest, CancelWhileDelayedStartTaskPending) { // Using a sliding window of 4 seconds, and max of 1 request, under a fast // run we expect to have a 4 second delay when posting the Start task. scoped_refptr<URLRequestThrottlerEntry> entry( - new URLRequestThrottlerEntry( - request_context()->throttler_manager(), - "", 4000, 1, 2000, 2.0, 0.0, 4000)); + new URLRequestThrottlerEntry(request_context()->throttler_manager(), + std::string(), + 4000, + 1, + 2000, + 2.0, + 0.0, + 4000)); request_context()->throttler_manager()->OverrideEntryForTests(url, entry); // Fake that a request has just started. entry->ReserveSendingTimeForNextRequest(base::TimeTicks()); diff --git a/net/url_request/url_request_throttler_simulation_unittest.cc b/net/url_request/url_request_throttler_simulation_unittest.cc index 3a5a399..cbb8be8 100644 --- a/net/url_request/url_request_throttler_simulation_unittest.cc +++ b/net/url_request/url_request_throttler_simulation_unittest.cc @@ -297,11 +297,9 @@ class Server : public DiscreteTimeSimulation::Actor { // Mock throttler entry used by Requester class. class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry { public: - explicit MockURLRequestThrottlerEntry( - URLRequestThrottlerManager* manager) - : URLRequestThrottlerEntry(manager, ""), - mock_backoff_entry_(&backoff_policy_) { - } + explicit MockURLRequestThrottlerEntry(URLRequestThrottlerManager* manager) + : URLRequestThrottlerEntry(manager, std::string()), + mock_backoff_entry_(&backoff_policy_) {} virtual const BackoffEntry* GetBackoffEntry() const OVERRIDE { return &mock_backoff_entry_; @@ -433,7 +431,7 @@ class Requester : public DiscreteTimeSimulation::Actor { if (!throttler_entry_->ShouldRejectRequest(server_->mock_request())) { int status_code = server_->HandleRequest(); MockURLRequestThrottlerHeaderAdapter response_headers(status_code); - throttler_entry_->UpdateWithResponse("", &response_headers); + throttler_entry_->UpdateWithResponse(std::string(), &response_headers); if (status_code == 200) { if (results_) diff --git a/net/url_request/url_request_throttler_test_support.cc b/net/url_request/url_request_throttler_test_support.cc index b6088ec..9d3f4e2 100644 --- a/net/url_request/url_request_throttler_test_support.cc +++ b/net/url_request/url_request_throttler_test_support.cc @@ -48,7 +48,7 @@ std::string MockURLRequestThrottlerHeaderAdapter::GetNormalizedValue( return fake_opt_out_value_; } - return ""; + return std::string(); } int MockURLRequestThrottlerHeaderAdapter::GetResponseCode() const { diff --git a/net/url_request/url_request_throttler_unittest.cc b/net/url_request/url_request_throttler_unittest.cc index cb20a95..ed3eb87 100644 --- a/net/url_request/url_request_throttler_unittest.cc +++ b/net/url_request/url_request_throttler_unittest.cc @@ -37,7 +37,7 @@ class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry { public: explicit MockURLRequestThrottlerEntry( net::URLRequestThrottlerManager* manager) - : net::URLRequestThrottlerEntry(manager, ""), + : net::URLRequestThrottlerEntry(manager, std::string()), mock_backoff_entry_(&backoff_policy_) { InitPolicy(); } @@ -46,7 +46,7 @@ class MockURLRequestThrottlerEntry : public URLRequestThrottlerEntry { const TimeTicks& exponential_backoff_release_time, const TimeTicks& sliding_window_release_time, const TimeTicks& fake_now) - : net::URLRequestThrottlerEntry(manager, ""), + : net::URLRequestThrottlerEntry(manager, std::string()), fake_time_now_(fake_now), mock_backoff_entry_(&backoff_policy_) { InitPolicy(); @@ -279,14 +279,14 @@ TEST_F(URLRequestThrottlerEntryTest, InterfaceNotDuringExponentialBackoff) { TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateFailure) { MockURLRequestThrottlerHeaderAdapter failure_response(503); - entry_->UpdateWithResponse("", &failure_response); + entry_->UpdateWithResponse(std::string(), &failure_response); EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_) << "A failure should increase the release_time"; } TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccess) { MockURLRequestThrottlerHeaderAdapter success_response(200); - entry_->UpdateWithResponse("", &success_response); + entry_->UpdateWithResponse(std::string(), &success_response); EXPECT_EQ(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_) << "A success should not add any delay"; } @@ -294,11 +294,11 @@ TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccess) { TEST_F(URLRequestThrottlerEntryTest, InterfaceUpdateSuccessThenFailure) { MockURLRequestThrottlerHeaderAdapter failure_response(503); MockURLRequestThrottlerHeaderAdapter success_response(200); - entry_->UpdateWithResponse("", &success_response); - entry_->UpdateWithResponse("", &failure_response); + entry_->UpdateWithResponse(std::string(), &success_response); + entry_->UpdateWithResponse(std::string(), &failure_response); EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), entry_->fake_time_now_) << "This scenario should add delay"; - entry_->UpdateWithResponse("", &success_response); + entry_->UpdateWithResponse(std::string(), &success_response); } TEST_F(URLRequestThrottlerEntryTest, IsEntryReallyOutdated) { @@ -324,7 +324,7 @@ TEST_F(URLRequestThrottlerEntryTest, IsEntryReallyOutdated) { TEST_F(URLRequestThrottlerEntryTest, MaxAllowedBackoff) { for (int i = 0; i < 30; ++i) { MockURLRequestThrottlerHeaderAdapter response_adapter(503); - entry_->UpdateWithResponse("", &response_adapter); + entry_->UpdateWithResponse(std::string(), &response_adapter); } TimeDelta delay = entry_->GetExponentialBackoffReleaseTime() - now_; @@ -335,7 +335,7 @@ TEST_F(URLRequestThrottlerEntryTest, MaxAllowedBackoff) { TEST_F(URLRequestThrottlerEntryTest, MalformedContent) { MockURLRequestThrottlerHeaderAdapter response_adapter(503); for (int i = 0; i < 5; ++i) - entry_->UpdateWithResponse("", &response_adapter); + entry_->UpdateWithResponse(std::string(), &response_adapter); TimeTicks release_after_failures = entry_->GetExponentialBackoffReleaseTime(); @@ -346,7 +346,7 @@ TEST_F(URLRequestThrottlerEntryTest, MalformedContent) { // response must also have been received). entry_->ReceivedContentWasMalformed(200); MockURLRequestThrottlerHeaderAdapter success_adapter(200); - entry_->UpdateWithResponse("", &success_adapter); + entry_->UpdateWithResponse(std::string(), &success_adapter); EXPECT_GT(entry_->GetExponentialBackoffReleaseTime(), release_after_failures); } @@ -475,7 +475,7 @@ void ExpectEntryAllowsAllOnErrorIfOptedOut( MockURLRequestThrottlerHeaderAdapter failure_adapter(503); for (int i = 0; i < 10; ++i) { // Host doesn't really matter in this scenario so we skip it. - entry->UpdateWithResponse("", &failure_adapter); + entry->UpdateWithResponse(std::string(), &failure_adapter); } EXPECT_NE(opted_out, entry->ShouldRejectRequest(request)); @@ -500,7 +500,7 @@ TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) { // Fake a response with the opt-out header. MockURLRequestThrottlerHeaderAdapter response_adapter( - "", + std::string(), MockURLRequestThrottlerEntry::kExponentialThrottlingDisableValue, 200); entry->UpdateWithResponse("www.google.com", &response_adapter); @@ -517,7 +517,8 @@ TEST_F(URLRequestThrottlerManagerTest, OptOutHeader) { // Fake a response with the opt-out header incorrectly specified. scoped_refptr<net::URLRequestThrottlerEntryInterface> no_opt_out_entry = manager.RegisterRequestUrl(GURL("http://www.nike.com/justdoit")); - MockURLRequestThrottlerHeaderAdapter wrong_adapter("", "yesplease", 200); + MockURLRequestThrottlerHeaderAdapter wrong_adapter( + std::string(), "yesplease", 200); no_opt_out_entry->UpdateWithResponse("www.nike.com", &wrong_adapter); ExpectEntryAllowsAllOnErrorIfOptedOut(no_opt_out_entry, false, request_); @@ -535,7 +536,7 @@ TEST_F(URLRequestThrottlerManagerTest, ClearOnNetworkChange) { MockURLRequestThrottlerHeaderAdapter failure_adapter(503); for (int j = 0; j < 10; ++j) { // Host doesn't really matter in this scenario so we skip it. - entry_before->UpdateWithResponse("", &failure_adapter); + entry_before->UpdateWithResponse(std::string(), &failure_adapter); } EXPECT_TRUE(entry_before->ShouldRejectRequest(request_)); diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc index 494e6b3..c3c68a1 100644 --- a/net/url_request/url_request_unittest.cc +++ b/net/url_request/url_request_unittest.cc @@ -2577,7 +2577,7 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequest) { &network_delegate); { - URLRequest r(test_server_.GetURL(""), &d, &context); + URLRequest r(test_server_.GetURL(std::string()), &d, &context); r.Start(); MessageLoop::current()->Run(); @@ -2626,21 +2626,21 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously1) { ASSERT_TRUE(test_server_.Start()); NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS, BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST, - test_server_.GetURL("")); + test_server_.GetURL(std::string())); } TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously2) { ASSERT_TRUE(test_server_.Start()); NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS, BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS, - test_server_.GetURL("")); + test_server_.GetURL(std::string())); } TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestSynchronously3) { ASSERT_TRUE(test_server_.Start()); NetworkDelegateCancelRequest(BlockingNetworkDelegate::SYNCHRONOUS, BlockingNetworkDelegate::ON_HEADERS_RECEIVED, - test_server_.GetURL("")); + test_server_.GetURL(std::string())); } // The following 3 tests check that the network delegate can cancel a request @@ -2649,21 +2649,21 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously1) { ASSERT_TRUE(test_server_.Start()); NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK, BlockingNetworkDelegate::ON_BEFORE_URL_REQUEST, - test_server_.GetURL("")); + test_server_.GetURL(std::string())); } TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously2) { ASSERT_TRUE(test_server_.Start()); NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK, BlockingNetworkDelegate::ON_BEFORE_SEND_HEADERS, - test_server_.GetURL("")); + test_server_.GetURL(std::string())); } TEST_F(URLRequestTestHTTP, NetworkDelegateCancelRequestAsynchronously3) { ASSERT_TRUE(test_server_.Start()); NetworkDelegateCancelRequest(BlockingNetworkDelegate::AUTO_CALLBACK, BlockingNetworkDelegate::ON_HEADERS_RECEIVED, - test_server_.GetURL("")); + test_server_.GetURL(std::string())); } // Tests that the network delegate can block and redirect a request to a new @@ -2992,7 +2992,7 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting1) { context.Init(); { - URLRequest r(test_server_.GetURL(""), &d, &context); + URLRequest r(test_server_.GetURL(std::string()), &d, &context); r.Start(); MessageLoop::current()->Run(); @@ -3028,7 +3028,7 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting2) { context.Init(); { - URLRequest r(test_server_.GetURL(""), &d, &context); + URLRequest r(test_server_.GetURL(std::string()), &d, &context); r.Start(); MessageLoop::current()->Run(); @@ -3063,7 +3063,7 @@ TEST_F(URLRequestTestHTTP, NetworkDelegateCancelWhileWaiting3) { context.Init(); { - URLRequest r(test_server_.GetURL(""), &d, &context); + URLRequest r(test_server_.GetURL(std::string()), &d, &context); r.Start(); MessageLoop::current()->Run(); @@ -3147,7 +3147,7 @@ TEST_F(URLRequestTestHTTP, GetTest_NoCache) { TestDelegate d; { - URLRequest r(test_server_.GetURL(""), &d, &default_context_); + URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -3213,7 +3213,7 @@ TEST_F(URLRequestTestHTTP, GetTest) { TestDelegate d; { - URLRequest r(test_server_.GetURL(""), &d, &default_context_); + URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -3235,7 +3235,7 @@ TEST_F(URLRequestTestHTTP, GetTestLoadTiming) { TestDelegate d; { - URLRequest r(test_server_.GetURL(""), &d, &default_context_); + URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -3319,7 +3319,7 @@ TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) { // An https server is sent a request with an https referer, // and responds with a redirect to an http url. The http // server should not be sent the referer. - GURL http_destination = test_server_.GetURL(""); + GURL http_destination = test_server_.GetURL(std::string()); TestDelegate d; URLRequest req(https_test_server.GetURL( "server-redirect?" + http_destination.spec()), &d, &default_context_); @@ -3336,9 +3336,9 @@ TEST_F(URLRequestTestHTTP, HTTPSToHTTPRedirectNoRefererTest) { TEST_F(URLRequestTestHTTP, RedirectLoadTiming) { ASSERT_TRUE(test_server_.Start()); - GURL destination_url = test_server_.GetURL(""); - GURL original_url = test_server_.GetURL( - "server-redirect?" + destination_url.spec()); + GURL destination_url = test_server_.GetURL(std::string()); + GURL original_url = + test_server_.GetURL("server-redirect?" + destination_url.spec()); TestDelegate d; URLRequest req(original_url, &d, &default_context_); req.Start(); @@ -3374,9 +3374,9 @@ TEST_F(URLRequestTestHTTP, RedirectLoadTiming) { TEST_F(URLRequestTestHTTP, MultipleRedirectTest) { ASSERT_TRUE(test_server_.Start()); - GURL destination_url = test_server_.GetURL(""); - GURL middle_redirect_url = test_server_.GetURL( - "server-redirect?" + destination_url.spec()); + GURL destination_url = test_server_.GetURL(std::string()); + GURL middle_redirect_url = + test_server_.GetURL("server-redirect?" + destination_url.spec()); GURL original_url = test_server_.GetURL( "server-redirect?" + middle_redirect_url.spec()); TestDelegate d; @@ -3492,7 +3492,7 @@ TEST_F(URLRequestTestHTTP, CancelTest2) { TestDelegate d; { - URLRequest r(test_server_.GetURL(""), &d, &default_context_); + URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); d.set_cancel_in_response_started(true); @@ -3513,7 +3513,7 @@ TEST_F(URLRequestTestHTTP, CancelTest3) { TestDelegate d; { - URLRequest r(test_server_.GetURL(""), &d, &default_context_); + URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); d.set_cancel_in_received_data(true); @@ -3537,7 +3537,7 @@ TEST_F(URLRequestTestHTTP, CancelTest4) { TestDelegate d; { - URLRequest r(test_server_.GetURL(""), &d, &default_context_); + URLRequest r(test_server_.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -4496,7 +4496,7 @@ TEST_F(HTTPSRequestTest, HTTPSGetTest) { TestDelegate d; { - URLRequest r(test_server.GetURL(""), &d, &default_context_); + URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -4526,7 +4526,7 @@ TEST_F(HTTPSRequestTest, HTTPSMismatchedTest) { TestDelegate d; { d.set_allow_certificate_errors(err_allowed); - URLRequest r(test_server.GetURL(""), &d, &default_context_); + URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -4561,7 +4561,7 @@ TEST_F(HTTPSRequestTest, HTTPSExpiredTest) { TestDelegate d; { d.set_allow_certificate_errors(err_allowed); - URLRequest r(test_server.GetURL(""), &d, &default_context_); + URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -4605,7 +4605,7 @@ TEST_F(HTTPSRequestTest, TLSv1Fallback) { TestURLRequestContext context(true); context.Init(); d.set_allow_certificate_errors(true); - URLRequest r(test_server.GetURL(""), &d, &context); + URLRequest r(test_server.GetURL(std::string()), &d, &context); r.Start(); MessageLoop::current()->Run(); @@ -4784,7 +4784,7 @@ TEST_F(HTTPSRequestTest, SSLv3Fallback) { TestURLRequestContext context(true); context.Init(); d.set_allow_certificate_errors(true); - URLRequest r(test_server.GetURL(""), &d, &context); + URLRequest r(test_server.GetURL(std::string()), &d, &context); r.Start(); MessageLoop::current()->Run(); @@ -4832,7 +4832,7 @@ TEST_F(HTTPSRequestTest, ClientAuthTest) { SSLClientAuthTestDelegate d; { - URLRequest r(test_server.GetURL(""), &d, &default_context_); + URLRequest r(test_server.GetURL(std::string()), &d, &default_context_); r.Start(); EXPECT_TRUE(r.is_pending()); @@ -5072,7 +5072,7 @@ class HTTPSOCSPTest : public HTTPSRequestTest { TestDelegate d; d.set_allow_certificate_errors(true); - URLRequest r(test_server.GetURL(""), &d, &context_); + URLRequest r(test_server.GetURL(std::string()), &d, &context_); r.Start(); MessageLoop::current()->Run(); diff --git a/net/websockets/websocket_net_log_params_unittest.cc b/net/websockets/websocket_net_log_params_unittest.cc index e3c92a9..0519390f 100644 --- a/net/websockets/websocket_net_log_params_unittest.cc +++ b/net/websockets/websocket_net_log_params_unittest.cc @@ -21,7 +21,7 @@ TEST(NetLogWebSocketHandshakeParameterTest, ToValue) { list->Append(new StringValue("Upgrade: WebSocket")); list->Append(new StringValue("Sec-WebSocket-Key1: 4 @1 46546xW%0l 1 5")); list->Append(new StringValue("Origin: http://example.com")); - list->Append(new StringValue("")); + list->Append(new StringValue(std::string())); list->Append(new StringValue("\\x00\\x01\\x0a\\x0d\\xff\\xfe\\x0d\\x0a")); DictionaryValue expected; |