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

remoting/client/plugin/pepper_port_allocator.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 "remoting/client/plugin/pepper_port_allocator.h"
 
 #include "base/bind.h"
 #include "base/string_number_conversions.h"
 #include "net/base/net_util.h"
 #include "ppapi/c/pp_errors.h"
@@ skipping 64 matching lines @@
 PepperPortAllocatorSession::PepperPortAllocatorSession(
     cricket::HttpPortAllocatorBase* allocator,
     const std::string& content_name,
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password,
     const std::vector<talk_base::SocketAddress>& stun_hosts,
     const std::vector<std::string>& relay_hosts,
     const std::string& relay_token,
     const pp::InstanceHandle& instance)
-    : HttpPortAllocatorSessionBase(
-        allocator, content_name, component, ice_username_fragment, ice_password,
-        stun_hosts, relay_hosts, relay_token, ""),
+    : HttpPortAllocatorSessionBase(allocator,
+                                   content_name,
+                                   component,
+                                   ice_username_fragment,
+                                   ice_password,
+                                   stun_hosts,
+                                   relay_hosts,
+                                   relay_token,
+                                   std::string()),
       instance_(instance),
       stun_address_resolver_(instance_),
       stun_port_(0),
       relay_response_received_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   if (stun_hosts.size() > 0) {
     stun_address_ = stun_hosts[0];
   }
 }
 
@@ skipping 24 matching lines @@
     }
     relay->ports = filtered_ports;
   }
   cricket::BasicPortAllocatorSession::ConfigReady(config);
 }
 
 void PepperPortAllocatorSession::GetPortConfigurations() {
   // Add an empty configuration synchronously, so a local connection
   // can be started immediately.
   ConfigReady(new cricket::PortConfiguration(
-      talk_base::SocketAddress(), "", ""));
+      talk_base::SocketAddress(), std::string(), std::string()));
 
   ResolveStunServerAddress();
   TryCreateRelaySession();
 }
 
 void PepperPortAllocatorSession::ResolveStunServerAddress() {
   if (stun_address_.IsNil()) {
     return;
   }
 
@@ skipping 45 matching lines @@
     // and Relay parameters are stored together in PortConfiguration
     // and ReceiveSessionResponse() doesn't save relay session
     // configuration for the case we resolve STUN address later. This
     // method invokes overriden ConfigReady() which then submits
     // resolved |stun_address_|.
     //
     // TODO(sergeyu): Refactor HttpPortAllocatorSessionBase to fix this.
     ReceiveSessionResponse(std::string(relay_response_body_.begin(),
                                        relay_response_body_.end()));
   } else {
-    ConfigReady(new cricket::PortConfiguration(stun_address_, "", ""));
+    ConfigReady(new cricket::PortConfiguration(
+        stun_address_, std::string(), std::string()));
   }
 }
 
 void PepperPortAllocatorSession::SendSessionRequest(
     const std::string& host,
     int port) {
   relay_url_loader_.reset(new pp::URLLoader(instance_));
   pp::URLRequestInfo request_info(instance_);
   std::string url = "https://" + host + ":" + base::IntToString(port) +
       GetSessionRequestUrl() + "&sn=1";
@@ skipping 88 matching lines @@
       new PepperPacketSocketFactory(instance));
   scoped_ptr<PepperPortAllocator> result(new PepperPortAllocator(
       instance, network_manager.Pass(), socket_factory.Pass()));
   return result.Pass();
 }
 
 PepperPortAllocator::PepperPortAllocator(
     const pp::InstanceHandle& instance,
     scoped_ptr<talk_base::NetworkManager> network_manager,
     scoped_ptr<talk_base::PacketSocketFactory> socket_factory)
-    : HttpPortAllocatorBase(network_manager.get(), socket_factory.get(), ""),
+    : HttpPortAllocatorBase(network_manager.get(),
+                            socket_factory.get(),
+                            std::string()),
       instance_(instance),
       network_manager_(network_manager.Pass()),
       socket_factory_(socket_factory.Pass()) {
   // TCP transport is disabled becase PseudoTCP works poorly over
   // it. ENABLE_SHARED_UFRAG flag is specified so that the same
   // username fragment is shared between all candidates for this
   // channel.
   set_flags(cricket::PORTALLOCATOR_DISABLE_TCP |
             cricket::PORTALLOCATOR_ENABLE_SHARED_UFRAG);
 }
 
 PepperPortAllocator::~PepperPortAllocator() {
 }
 
 cricket::PortAllocatorSession* PepperPortAllocator::CreateSessionInternal(
     const std::string& content_name,
     int component,
     const std::string& ice_username_fragment,
     const std::string& ice_password) {
    return new PepperPortAllocatorSession(
        this, content_name, component, ice_username_fragment, ice_password,
        stun_hosts(), relay_hosts(), relay_token(), instance_);
 }
 
 }  // namespace remoting