Rewrite std::string("") to std::string(), Linux edition.

net/base/net_util_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/base/net_util.h"
 
 #include <string.h>
 
 #include <algorithm>
 
@@ skipping 2578 matching lines @@
   EXPECT_EQ(WideToUTF16(L"8080"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/\x30B0/"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"q=\x30B0"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"\x30B0"),
       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"),
       formatted.substr(parsed.scheme.begin, parsed.scheme.len));
   EXPECT_FALSE(parsed.username.is_valid());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"host"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"81"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/path"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"query"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"ref"),
       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());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"host"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8000"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/a"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"b=c"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"d"),
       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());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_EQ(WideToUTF16(L"http"),
       formatted.substr(parsed.scheme.begin, parsed.scheme.len));
   EXPECT_EQ(WideToUTF16(L"ftp.host"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"8000"),
       formatted.substr(parsed.port.begin, parsed.port.len));
   EXPECT_EQ(WideToUTF16(L"/a"),
       formatted.substr(parsed.path.begin, parsed.path.len));
   EXPECT_EQ(WideToUTF16(L"b=c"),
       formatted.substr(parsed.query.begin, parsed.query.len));
   EXPECT_EQ(WideToUTF16(L"d"),
       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());
   EXPECT_FALSE(parsed.password.is_valid());
   EXPECT_FALSE(parsed.port.is_valid());
   EXPECT_TRUE(parsed.path.is_valid());
   EXPECT_FALSE(parsed.query.is_valid());
   EXPECT_FALSE(parsed.ref.is_valid());
   EXPECT_EQ(WideToUTF16(L"f"),
       formatted.substr(parsed.host.begin, parsed.host.len));
   EXPECT_EQ(WideToUTF16(L"/"),
       formatted.substr(parsed.path.begin, parsed.path.len));
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // results in the original GURL, for each ASCII character in the path.
 TEST(NetUtilTest, FormatUrlRoundTripPathASCII) {
   for (unsigned char test_char = 32; test_char < 128; ++test_char) {
     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());
   }
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // results in the original GURL, for each escaped ASCII character in the path.
 TEST(NetUtilTest, FormatUrlRoundTripPathEscaped) {
   for (unsigned char test_char = 32; test_char < 128; ++test_char) {
     std::string original_url("http://www.google.com/");
     original_url.push_back('%');
     original_url.append(base::HexEncode(&test_char, 1));
 
     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());
   }
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // results in the original GURL, for each ASCII character in the query.
 TEST(NetUtilTest, FormatUrlRoundTripQueryASCII) {
   for (unsigned char test_char = 32; test_char < 128; ++test_char) {
     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());
   }
 }
 
 // Make sure that calling FormatUrl on a GURL and then converting back to a GURL
 // only results in a different GURL for certain characters.
 TEST(NetUtilTest, FormatUrlRoundTripQueryEscaped) {
   // A full list of characters which FormatURL should unescape and GURL should
   // not escape again, when they appear in a query string.
   const char* kUnescapedCharacters =
       "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_~";
   for (unsigned char test_char = 0; test_char < 128; ++test_char) {
     std::string original_url("http://www.google.com/?");
     original_url.push_back('%');
     original_url.append(base::HexEncode(&test_char, 1));
 
     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))) {
       EXPECT_NE(url.spec(), GURL(formatted).spec());
     } else {
       EXPECT_EQ(url.spec(), GURL(formatted).spec());
     }
   }
 }
 
@@ skipping 279 matching lines @@
   EXPECT_EQ("file:///tmp/test.html",
             GetHostOrSpecFromURL(GURL("file:///tmp/test.html")));
 }
 
 // Test that invalid IP literals fail to parse.
 TEST(NetUtilTest, ParseIPLiteralToNumber_FailParse) {
   IPAddressNumber number;
 
   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));
 }
 
 // Test parsing an IPv4 literal.
 TEST(NetUtilTest, ParseIPLiteralToNumber_IPv4) {
   IPAddressNumber number;
   EXPECT_TRUE(ParseIPLiteralToNumber("192.168.0.1", &number));
   EXPECT_EQ("192,168,0,1", DumpIPNumber(number));
@@ skipping 214 matching lines @@
       if (it->address[i] != 0) {
         all_zeroes = false;
         break;
       }
     }
     EXPECT_FALSE(all_zeroes);
   }
 }
 
 }  // namespace net