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

net/http/http_proxy_client_socket_pool_spdy2_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/http/http_proxy_client_socket_pool.h"
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
@@ skipping 29 matching lines @@
 };
 
 typedef ::testing::TestWithParam<HttpProxyType> TestWithHttpParam;
 
 }  // namespace
 
 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,
                          NULL,
                          session_deps_.ssl_config_service.get(),
                          BoundNetLog().net_log()),
         session_(CreateNetworkSession()),
         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() {
   }
 
   void AddAuthToCache() {
     const base::string16 kFoo(ASCIIToUTF16("foo"));
     const base::string16 kBar(ASCIIToUTF16("bar"));
     GURL proxy_url(GetParam() == HTTP ? "http://proxy" : "https://proxy:80");
     session_->http_auth_cache()->Add(proxy_url,
                                      "MyRealm1",
@@ skipping 11 matching lines @@
 
   scoped_refptr<SSLSocketParams> GetSslParams() {
     if (GetParam() == HTTP)
       return scoped_refptr<SSLSocketParams>();
     return ignored_ssl_socket_params_;
   }
 
   // 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() {
     return GetParams(true);
   }
 
   scoped_refptr<HttpProxySocketParams> GetNoTunnelParams() {
     return GetParams(false);
   }
 
@@ skipping 450 matching lines @@
     // Make sure Location header was included and correct.
     std::string location;
     EXPECT_TRUE(headers->IsRedirect(&location));
     EXPECT_EQ(location, redirectTarget);
   }
 }
 
 // It would be nice to also test the timeouts in HttpProxyClientSocketPool.
 
 }  // namespace net