Optimize chained string concatenation in SPDY code.

net/spdy/spdy_session.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/spdy/spdy_session.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/basictypes.h"
@@ skipping 46 matching lines @@
 
 // Minimum seconds that unclaimed pushed streams will be kept in memory.
 const int kMinPushedStreamLifetimeSeconds = 300;
 
 scoped_ptr<base::ListValue> SpdyHeaderBlockToListValue(
     const SpdyHeaderBlock& headers,
     net::NetLog::LogLevel log_level) {
   scoped_ptr<base::ListValue> headers_list(new base::ListValue());
   for (SpdyHeaderBlock::const_iterator it = headers.begin();
        it != headers.end(); ++it) {
-    headers_list->AppendString(
-        it->first + ": " +
-        ElideHeaderValueForNetLog(log_level, it->first, it->second));
+    headers_list->AppendString(std::string(it->first).append(": ").append(
+        ElideHeaderValueForNetLog(log_level, it->first, it->second)));
   }
   return headers_list.Pass();
 }
 
 base::Value* NetLogSpdySynStreamSentCallback(const SpdyHeaderBlock* headers,
                                              bool fin,
                                              bool unidirectional,
                                              SpdyPriority spdy_priority,
                                              SpdyStreamId stream_id,
                                              NetLog::LogLevel log_level) {
@@ skipping 2448 matching lines @@
       LOG(WARNING) << "Received WINDOW_UPDATE for session when "
                    << "session flow control is not turned on";
       // TODO(akalin): Record an error and close the session.
       return;
     }
 
     if (delta_window_size < 1u) {
       RecordProtocolErrorHistogram(PROTOCOL_ERROR_INVALID_WINDOW_UPDATE_SIZE);
       DoDrainSession(
           ERR_SPDY_PROTOCOL_ERROR,
-          "Received WINDOW_UPDATE with an invalid delta_window_size " +
-              base::UintToString(delta_window_size));
+          std::string(
+              "Received WINDOW_UPDATE with an invalid delta_window_size ")
+              .append(base::UintToString(delta_window_size)));

[mmenke, 2015/03/09 20:21:58]

This could just be:

base::StringPrintf("Received... %i", delta_window_size);

(StringPrintf may be slower, but given that this is done on errors only, I don't
think performance matters...and it may well be faster, anyways, since it creates
2 fewer std::strings)

       return;
     }
 
     IncreaseSendWindowSize(static_cast<int32>(delta_window_size));
   } else {
     // WINDOW_UPDATE for a stream.
     if (flow_control_state_ < FLOW_CONTROL_STREAM) {
       // TODO(akalin): Record an error and close the session.
       LOG(WARNING) << "Received WINDOW_UPDATE for stream " << stream_id
                    << " when flow control is not turned on";
@@ skipping 590 matching lines @@
 
   DCHECK_EQ(flow_control_state_, FLOW_CONTROL_STREAM_AND_SESSION);
   DCHECK_GE(delta_window_size, 1);
 
   // Check for overflow.
   int32 max_delta_window_size = kint32max - session_send_window_size_;
   if (delta_window_size > max_delta_window_size) {
     RecordProtocolErrorHistogram(PROTOCOL_ERROR_INVALID_WINDOW_UPDATE_SIZE);
     DoDrainSession(
         ERR_SPDY_PROTOCOL_ERROR,
-        "Received WINDOW_UPDATE [delta: " +
-            base::IntToString(delta_window_size) +
-            "] for session overflows session_send_window_size_ [current: " +
-            base::IntToString(session_send_window_size_) + "]");
+        std::string("Received WINDOW_UPDATE [delta: ")
+            .append(base::IntToString(delta_window_size))
+            .append(
+                 "] for session overflows session_send_window_size_ [current: ")
+            .append(base::IntToString(session_send_window_size_))
+            .append("]"));
     return;
   }
 
   session_send_window_size_ += delta_window_size;
 
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_UPDATE_SEND_WINDOW,
       base::Bind(&NetLogSpdySessionWindowUpdateCallback,
                  delta_window_size, session_send_window_size_));
 
@@ skipping 61 matching lines @@
 void SpdySession::DecreaseRecvWindowSize(int32 delta_window_size) {
   CHECK(in_io_loop_);
   DCHECK_EQ(flow_control_state_, FLOW_CONTROL_STREAM_AND_SESSION);
   DCHECK_GE(delta_window_size, 1);
 
   // Since we never decrease the initial receive window size,
   // |delta_window_size| should never cause |recv_window_size_| to go
   // negative. If we do, the receive window isn't being respected.
   if (delta_window_size > session_recv_window_size_) {
     RecordProtocolErrorHistogram(PROTOCOL_ERROR_RECEIVE_WINDOW_VIOLATION);
-    DoDrainSession(
-        ERR_SPDY_FLOW_CONTROL_ERROR,
-        "delta_window_size is " + base::IntToString(delta_window_size) +
-            " in DecreaseRecvWindowSize, which is larger than the receive " +
-            "window size of " + base::IntToString(session_recv_window_size_));
+    DoDrainSession(ERR_SPDY_FLOW_CONTROL_ERROR,
+                   std::string("delta_window_size is ")
+                       .append(base::IntToString(delta_window_size))
+                       .append(
+                            " in DecreaseRecvWindowSize, which is larger than "
+                            "the receive window size of ")
+                       .append(base::IntToString(session_recv_window_size_)));
     return;
   }
 
   session_recv_window_size_ -= delta_window_size;
   net_log_.AddEvent(
       NetLog::TYPE_SPDY_SESSION_UPDATE_RECV_WINDOW,
       base::Bind(&NetLogSpdySessionWindowUpdateCallback,
                  -delta_window_size, session_recv_window_size_));
 }
 
@@ skipping 41 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net