Cleanup: Pass std::string as const reference if possible

net/udp/udp_socket_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/udp/udp_socket.h"
 
 #include "net/udp/udp_client_socket.h"
 #include "net/udp/udp_server_socket.h"
 
 #include "base/basictypes.h"
@@ skipping 35 matching lines @@
     if (rv < 0)
       return std::string();  // error!
     return std::string(buffer_->data(), rv);
   }
 
   // Loop until |msg| has been written to the socket or until an
   // error occurs.
   // If |address| is specified, then it is used for the destination
   // to send to. Otherwise, will send to the last socket this server
   // received from.
-  int SendToSocket(UDPServerSocket* socket, std::string msg) {
+  int SendToSocket(UDPServerSocket* socket, const std::string& msg) {
     return SendToSocket(socket, msg, recv_from_address_);
   }
 
   int SendToSocket(UDPServerSocket* socket,
                    std::string msg,
                    const IPEndPoint& address) {
     TestCompletionCallback callback;
 
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
@@ skipping 20 matching lines @@
     int rv = socket->Read(buffer_.get(), kMaxRead, callback.callback());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     if (rv < 0)
       return std::string();  // error!
     return std::string(buffer_->data(), rv);
   }
 
   // Loop until |msg| has been written to the socket or until an
   // error occurs.
-  int WriteSocket(UDPClientSocket* socket, std::string msg) {
+  int WriteSocket(UDPClientSocket* socket, const std::string& msg) {
     TestCompletionCallback callback;
 
     int length = msg.length();
     scoped_refptr<StringIOBuffer> io_buffer(new StringIOBuffer(msg));
     scoped_refptr<DrainableIOBuffer> buffer(
         new DrainableIOBuffer(io_buffer.get(), length));
 
     int bytes_sent = 0;
     while (buffer->BytesRemaining()) {
       int rv = socket->Write(
           buffer.get(), buffer->BytesRemaining(), callback.callback());
       if (rv == ERR_IO_PENDING)
         rv = callback.WaitForResult();
       if (rv <= 0)
         return bytes_sent > 0 ? bytes_sent : rv;
       bytes_sent += rv;
       buffer->DidConsume(rv);
     }
     return bytes_sent;
   }
 
-  void WriteSocketIgnoreResult(UDPClientSocket* socket, std::string msg) {
+  void WriteSocketIgnoreResult(UDPClientSocket* socket,
+                               const std::string& msg) {
     WriteSocket(socket, msg);
   }
 
   // Creates an address from ip address and port and writes it to |*address|.
-  void CreateUDPAddress(std::string ip_str, uint16 port, IPEndPoint* address) {
+  void CreateUDPAddress(const std::string& ip_str,
+                        uint16 port,
+                        IPEndPoint* address) {
     IPAddressNumber ip_number;
     bool rv = ParseIPLiteralToNumber(ip_str, &ip_number);
     if (!rv)
       return;
     *address = IPEndPoint(ip_number, port);
   }
 
   // Run unit test for a connection test.
   // |use_nonblocking_io| is used to switch between overlapped and non-blocking
   // IO on Windows. It has no effect in other ports.
@@ skipping 660 matching lines @@
   g_expected_traffic_type = QOSTrafficTypeExcellentEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_NO_CHANGE));
   g_expected_dscp = DSCP_DEFAULT;
   g_expected_traffic_type = QOSTrafficTypeBestEffort;
   EXPECT_EQ(OK, client.SetDiffServCodePoint(DSCP_DEFAULT));
   client.Close();
 }
 #endif
 
 }  // namespace net