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

net/tools/dump_cache/url_to_filename_encoder_unittest.cc

 // Copyright (c) 2010 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/tools/dump_cache/url_to_filename_encoder.h"
 
 #include <string>
 #include <vector>
 
 #include "base/string_piece.h"
@@ skipping 39 matching lines @@
       char c = escaped_word[i];
       EXPECT_EQ(string::npos, kInvalidChars.find(c));
       EXPECT_NE(invalid_slash, c);
       EXPECT_NE('\0', c);  // only invalid character in Posix
       EXPECT_GT(0x7E, c);  // only English printable characters
     }
   }
 
   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, '\\');
     UrlToFilenameEncoder::Decode(escaped_word, '/', &url);
     EXPECT_EQ(in_word, url);
   }
 
   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);
     EXPECT_EQ(in_word, url);
   }
 
   void ValidateNoChange(const string& word) {
     // We always suffix the leaf with kEscapeChar, unless the leaf is empty.
     Validate(word, word + escape_);
   }
@@ skipping 18 matching lines @@
       UrlToFilenameEncoder::Decode(encoded_filename, kDirSeparator,
                                    &decoded_url);
       if (url != decoded_url) {
         EXPECT_EQ(url, "http://" + decoded_url);
       }
     }
   }
 
   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);
   }
 
   string escape_;
   string dir_sep_;
 };
 
 TEST_F(UrlToFilenameEncoderTest, DoesNotEscape) {
-  ValidateNoChange("");
+  ValidateNoChange(std::string());
   ValidateNoChange("abcdefg");
   ValidateNoChange("abcdefghijklmnopqrstuvwxyz");
   ValidateNoChange("ZYXWVUT");
   ValidateNoChange("ZYXWVUTSRQPONMLKJIHGFEDCBA");
   ValidateNoChange("01234567689");
   ValidateNoChange("_.=+-");
   ValidateNoChange("abcdefghijklmnopqrstuvwxyzZYXWVUTSRQPONMLKJIHGFEDCBA"
                    "01234567689_.=+-");
   ValidateNoChange("index.html");
   ValidateNoChange("/");
@@ skipping 51 matching lines @@
                     "www.google.com" + dir_sep_ + "x" + dir_sep_ + "search" +
                     escape_ + "3Fhl=en" + escape_ + "26q=dogs" + escape_ +
                     "26oq=" + escape_);
   ValidateUrlOldNew("http://www.foo.com/a//",
                     "www.foo.com" + dir_sep_ + "ax255Cx255Cindexx2Ehtml",
                     "www.foo.com" + dir_sep_ + "a" + dir_sep_ + escape_ + "2F" +
                     escape_);
 
   // 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_);
   ValidateUrlOldNew(
       "http://blogutils.net/olct/online.php?"
       "site=http://thelwordfanfics.blogspot.&interval=600",
 
       "blogutils.net" + dir_sep_ + "olct" + dir_sep_ + "onlinex2Ephpx3F"
       "sitex3Dhttpx3Ax255Cx255Cthelwordfanficsx2Eblogspotx2Ex26intervalx3D600",
 
@@ skipping 112 matching lines @@
   Validate("/a/b/c", "/a/b/c" + escape_);        // c is leaf file "c,"
   Validate("/a/b/c/d", "/a/b/c/d" + escape_);    // c is directory "c"
   Validate("/a/b/c/d/", "/a/b/c/d/" + escape_);
 }
 
 
 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());
   ASSERT_LT(UrlToFilenameEncoder::kMaximumSubdirectoryLength,
             escaped_word.size());
   // Check that the backslash got inserted at the correct spot.
   EXPECT_EQ('\\', escaped_word[
       UrlToFilenameEncoder::kMaximumSubdirectoryLength]);
 }
 
 }  // namespace net