Add SpdyString alias for std::string in net/spdy.

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 <limits>
 #include <map>
 #include <utility>
@@ skipping 120 matching lines @@
     NetLogCaptureMode capture_mode) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->Set("headers", ElideSpdyHeaderBlockForNetLog(*headers, capture_mode));
   dict->SetBoolean("fin", fin);
   dict->SetInteger("stream_id", stream_id);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdySessionCloseCallback(
     int net_error,
-    const std::string* description,
+    const SpdyString* description,
     NetLogCaptureMode /* capture_mode */) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("net_error", net_error);
   dict->SetString("description", *description);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdySessionCallback(
     const HostPortProxyPair* host_pair,
     NetLogCaptureMode /* capture_mode */) {
@@ skipping 92 matching lines @@
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetString(
       "error_code",
       SpdyStringPrintf("%u (%s)", error_code, ErrorCodeToString(error_code)));
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdySendRstStreamCallback(
     SpdyStreamId stream_id,
     SpdyErrorCode error_code,
-    const std::string* description,
+    const SpdyString* description,
     NetLogCaptureMode /* capture_mode */) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetString(
       "error_code",
       SpdyStringPrintf("%u (%s)", error_code, ErrorCodeToString(error_code)));
   dict->SetString("description", *description);
   return std::move(dict);
 }
 
@@ skipping 48 matching lines @@
   dict->SetInteger("stream_id", stream_id);
   dict->SetString("url", url->spec());
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdySessionStalledCallback(
     size_t num_active_streams,
     size_t num_created_streams,
     size_t num_pushed_streams,
     size_t max_concurrent_streams,
-    const std::string& url,
+    const SpdyString& url,
     NetLogCaptureMode capture_mode) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("num_active_streams", num_active_streams);
   dict->SetInteger("num_created_streams", num_created_streams);
   dict->SetInteger("num_pushed_streams", num_pushed_streams);
   dict->SetInteger("max_concurrent_streams", max_concurrent_streams);
   dict->SetString("url", url);
   return std::move(dict);
 }
 
@@ skipping 337 matching lines @@
 }
 
 size_t SpdySession::UnclaimedPushedStreamContainer::EstimateMemoryUsage()
     const {
   return SpdyEstimateMemoryUsage(streams_);
 }
 
 // static
 bool SpdySession::CanPool(TransportSecurityState* transport_security_state,
                           const SSLInfo& ssl_info,
-                          const std::string& old_hostname,
-                          const std::string& new_hostname) {
+                          const SpdyString& old_hostname,
+                          const SpdyString& new_hostname) {
   // Pooling is prohibited if the server cert is not valid for the new domain,
   // and for connections on which client certs were sent. It is also prohibited
   // when channel ID was sent if the hosts are from different eTLDs+1.
   if (IsCertStatusError(ssl_info.cert_status))
     return false;
 
   if (ssl_info.client_cert_sent)
     return false;
 
   if (ssl_info.channel_id_sent &&
       ChannelIDService::GetDomainForHost(new_hostname) !=
           ChannelIDService::GetDomainForHost(old_hostname)) {
     return false;
   }
 
   if (!ssl_info.cert->VerifyNameMatch(new_hostname, false))
     return false;
 
-  std::string pinning_failure_log;
+  SpdyString pinning_failure_log;
   // DISABLE_PIN_REPORTS is set here because this check can fail in
   // normal operation without being indicative of a misconfiguration or
   // attack. Port is left at 0 as it is never used.
   if (transport_security_state->CheckPublicKeyPins(
           HostPortPair(new_hostname, 0), ssl_info.is_issued_by_known_root,
           ssl_info.public_key_hashes, ssl_info.unverified_cert.get(),
           ssl_info.cert.get(), TransportSecurityState::DISABLE_PIN_REPORTS,
           &pinning_failure_log) ==
       TransportSecurityState::PKPStatus::VIOLATED) {
     return false;
@@ skipping 191 matching lines @@
     SendInitialData();
   pool_ = pool;
 
   // Bootstrap the read loop.
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&SpdySession::PumpReadLoop, weak_factory_.GetWeakPtr(),
                  READ_STATE_DO_READ, OK));
 }
 
-bool SpdySession::VerifyDomainAuthentication(const std::string& domain) {
+bool SpdySession::VerifyDomainAuthentication(const SpdyString& domain) {
   if (availability_state_ == STATE_DRAINING)
     return false;
 
   SSLInfo ssl_info;
   if (!GetSSLInfo(&ssl_info))
     return true;  // This is not a secure session, so all domains are okay.
 
   return CanPool(transport_security_state_, ssl_info, host_port_pair().host(),
                  domain);
 }
@@ skipping 184 matching lines @@
   if (it == created_streams_.end()) {
     NOTREACHED();
     return;
   }
 
   CloseCreatedStreamIterator(it, status);
 }
 
 void SpdySession::ResetStream(SpdyStreamId stream_id,
                               SpdyErrorCode error_code,
-                              const std::string& description) {
+                              const SpdyString& description) {
   DCHECK_NE(stream_id, 0u);
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     NOTREACHED();
     return;
   }
 
   ResetStreamIterator(it, error_code, description);
 }
@@ skipping 43 matching lines @@
 
 void SpdySession::SendStreamWindowUpdate(SpdyStreamId stream_id,
                                          uint32_t delta_window_size) {
   ActiveStreamMap::const_iterator it = active_streams_.find(stream_id);
   CHECK(it != active_streams_.end());
   CHECK_EQ(it->second->stream_id(), stream_id);
   SendWindowUpdateFrame(stream_id, delta_window_size, it->second->priority());
 }
 
 void SpdySession::CloseSessionOnError(Error err,
-                                      const std::string& description) {
+                                      const SpdyString& description) {
   DCHECK_LT(err, ERR_IO_PENDING);
   DoDrainSession(err, description);
 }
 
 void SpdySession::MakeUnavailable() {
   if (availability_state_ == STATE_AVAILABLE) {
     availability_state_ = STATE_GOING_AWAY;
     pool_->MakeSessionUnavailable(GetWeakPtr());
   }
 }
@@ skipping 374 matching lines @@
     // probably should be.
     EnqueueResetStreamFrame(stream_id, request_priority,
                             ERROR_CODE_REFUSED_STREAM,
                             "push stream request received when going away");
     return;
   }
 
   if (associated_stream_id == 0) {
     // In HTTP/2 0 stream id in PUSH_PROMISE frame leads to framer error and
     // session going away. We should never get here.
-    std::string description = SpdyStringPrintf(
+    SpdyString description = SpdyStringPrintf(
         "Received invalid associated stream id %d for pushed stream %d",
         associated_stream_id, stream_id);
     EnqueueResetStreamFrame(stream_id, request_priority,
                             ERROR_CODE_REFUSED_STREAM, description);
     return;
   }
 
   streams_pushed_count_++;
 
   // TODO(mbelshe): DCHECK that this is a GET method?
@@ skipping 159 matching lines @@
 
 void SpdySession::CloseCreatedStreamIterator(CreatedStreamSet::iterator it,
                                              int status) {
   std::unique_ptr<SpdyStream> owned_stream(*it);
   created_streams_.erase(it);
   DeleteStream(std::move(owned_stream), status);
 }
 
 void SpdySession::ResetStreamIterator(ActiveStreamMap::iterator it,
                                       SpdyErrorCode error_code,
-                                      const std::string& description) {
+                                      const SpdyString& description) {
   // Send the RST_STREAM frame first as CloseActiveStreamIterator()
   // may close us.
   SpdyStreamId stream_id = it->first;
   RequestPriority priority = it->second->priority();
   EnqueueResetStreamFrame(stream_id, priority, error_code, description);
 
   // Removes any pending writes for the stream except for possibly an
   // in-flight one.
   CloseActiveStreamIterator(it, ERR_SPDY_PROTOCOL_ERROR);
 }
 
 void SpdySession::EnqueueResetStreamFrame(SpdyStreamId stream_id,
                                           RequestPriority priority,
                                           SpdyErrorCode error_code,
-                                          const std::string& description) {
+                                          const SpdyString& description) {
   DCHECK_NE(stream_id, 0u);
 
   net_log().AddEvent(NetLogEventType::HTTP2_SESSION_SEND_RST_STREAM,
                      base::Bind(&NetLogSpdySendRstStreamCallback, stream_id,
                                 error_code, &description));
 
   DCHECK(buffered_spdy_framer_.get());
   std::unique_ptr<SpdySerializedFrame> rst_frame(
       buffered_spdy_framer_->CreateRstStream(stream_id, error_code));
 
@@ skipping 663 matching lines @@
 #endif
 }
 
 void SpdySession::DcheckDraining() const {
   DcheckGoingAway();
   DCHECK_EQ(availability_state_, STATE_DRAINING);
   DCHECK(active_streams_.empty());
   DCHECK(unclaimed_pushed_streams_.empty());
 }
 
-void SpdySession::DoDrainSession(Error err, const std::string& description) {
+void SpdySession::DoDrainSession(Error err, const SpdyString& description) {
   if (availability_state_ == STATE_DRAINING) {
     return;
   }
   MakeUnavailable();
 
   // Mark host_port_pair requiring HTTP/1.1 for subsequent connections.
   if (err == ERR_HTTP_1_1_REQUIRED) {
     http_server_properties_->SetHTTP11Required(host_port_pair());
   }
 
@@ skipping 30 matching lines @@
     DcheckGoingAway();
   } else {
     StartGoingAway(0, err);
   }
   DcheckDraining();
   MaybePostWriteLoop();
 }
 
 void SpdySession::LogAbandonedStream(SpdyStream* stream, Error status) {
   DCHECK(stream);
-  std::string description =
+  SpdyString description =
       SpdyStringPrintf("ABANDONED (stream_id=%d): ", stream->stream_id()) +
       stream->url().spec();
   stream->LogStreamError(status, description);
   // We don't increment the streams abandoned counter here. If the
   // stream isn't active (i.e., it hasn't written anything to the wire
   // yet) then it's as if it never existed. If it is active, then
   // LogAbandonedActiveStream() will increment the counters.
 }
 
 void SpdySession::LogAbandonedActiveStream(ActiveStreamMap::const_iterator it,
@@ skipping 62 matching lines @@
   next_unclaimed_push_stream_sweep_time_ =
       time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
 }
 
 void SpdySession::OnError(SpdyFramer::SpdyFramerError spdy_framer_error) {
   CHECK(in_io_loop_);
 
   RecordProtocolErrorHistogram(
       MapFramerErrorToProtocolError(spdy_framer_error));
-  std::string description =
+  SpdyString description =
       SpdyStringPrintf("Framer error: %d (%s).", spdy_framer_error,
                        SpdyFramer::SpdyFramerErrorToString(spdy_framer_error));
   DoDrainSession(MapFramerErrorToNetError(spdy_framer_error), description);
 }
 
 void SpdySession::OnStreamError(SpdyStreamId stream_id,
-                                const std::string& description) {
+                                const SpdyString& description) {
   CHECK(in_io_loop_);
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // We still want to send a frame to reset the stream even if we
     // don't know anything about it.
     EnqueueResetStreamFrame(stream_id, IDLE, ERROR_CODE_PROTOCOL_ERROR,
                             description);
     return;
   }
@@ skipping 583 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net