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

net/http/http_auth_cache_unittest.cc

 // Copyright (c) 2011 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 <string>
 
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 88 matching lines @@
                           HttpAuth::AUTH_SERVER));
   cache.Add(origin, realm2_handler->realm(), realm2_handler->auth_scheme(),
             "Basic realm=Realm2",
             CreateASCIICredentials("realm2-user", "realm2-password"),
             "/foo2/index.html");
 
   scoped_ptr<HttpAuthHandler> realm3_basic_handler(
       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,
                           kRealm3,
                           HttpAuth::AUTH_PROXY));
   cache.Add(origin, realm3_digest_handler->realm(),
             realm3_digest_handler->auth_scheme(), "Digest realm=Realm3",
             CreateASCIICredentials("realm3-digest-user",
                                    "realm3-digest-password"),
             "/baz/index.html");
@@ skipping 74 matching lines @@
   entry = cache.LookupByPath(origin, "/foo2/");
   EXPECT_TRUE(realm2_entry == entry);
   entry = cache.LookupByPath(origin, "/foo2");
   EXPECT_TRUE(realm4_entry == entry);
   entry = cache.LookupByPath(origin, "/");
   EXPECT_TRUE(realm4_entry == entry);
 
   // 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
   HttpAuthCache::Entry* realm3_digest_entry =
       cache.Lookup(origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
   EXPECT_FALSE(NULL == realm3_digest_entry);
   entry = cache.LookupByPath(origin, "/baz/index.html");
   EXPECT_TRUE(realm3_digest_entry == entry);
   entry = cache.LookupByPath(origin, "/baz/");
   EXPECT_TRUE(realm3_digest_entry == entry);
   entry = cache.LookupByPath(origin, "/baz");
   EXPECT_FALSE(realm3_digest_entry == entry);
 
   // Confirm we find the same realm, different auth scheme by path lookup
   HttpAuthCache::Entry* realm3DigestEntry =
       cache.Lookup(origin, kRealm3, HttpAuth::AUTH_SCHEME_DIGEST);
   EXPECT_FALSE(NULL == realm3DigestEntry);
   entry = cache.LookupByPath(origin, "/baz/index.html");
   EXPECT_TRUE(realm3DigestEntry == entry);
   entry = cache.LookupByPath(origin, "/baz/");
   EXPECT_TRUE(realm3DigestEntry == entry);
   entry = cache.LookupByPath(origin, "/baz");
   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());
 }
 
 TEST(HttpAuthCacheTest, AddPath) {
   HttpAuthCache::Entry entry;
 
   // All of these paths have a common root /1/2/2/4/5/
   entry.AddPath("/1/2/3/4/5/x.txt");
@@ skipping 288 matching lines @@
 
   std::string GeneratePath(int realm_i, int path_i) {
     return base::StringPrintf("/%d/%d/x/y", realm_i, path_i);
   }
 
   void AddRealm(int realm_i) {
     AddPathToRealm(realm_i, 0);
   }
 
   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));
   }
 
   void CheckRealmExistence(int realm_i, bool exists) {
     const HttpAuthCache::Entry* entry =
         cache_.Lookup(
             origin_, GenerateRealm(realm_i), HttpAuth::AUTH_SCHEME_BASIC);
     if (exists) {
       EXPECT_FALSE(entry == NULL);
@@ skipping 58 matching lines @@
     CheckPathExistence(0, i, false);
 
   for (int i = 0; i < kMaxPaths; ++i)
     CheckPathExistence(0, i + 3, true);
 
   for (int i = 0; i < kMaxRealms; ++i)
     CheckRealmExistence(i, true);
 }
 
 }  // namespace net