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

net/spdy/spdy_stream.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_stream.h"
 
 #include <algorithm>
 #include <limits>
 #include <utility>
 
@@ skipping 17 matching lines @@
 #include "net/spdy/spdy_http_utils.h"
 #include "net/spdy/spdy_session.h"
 
 namespace net {
 
 namespace {
 
 std::unique_ptr<base::Value> NetLogSpdyStreamErrorCallback(
     SpdyStreamId stream_id,
     int status,
-    const std::string* description,
+    const SpdyString* description,
     NetLogCaptureMode /* capture_mode */) {
   std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetInteger("status", status);
   dict->SetString("description", *description);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdyStreamWindowUpdateCallback(
     SpdyStreamId stream_id,
@@ skipping 201 matching lines @@
 
   // Ignore late WINDOW_UPDATEs.
   if (IsClosed())
     return;
 
   if (send_window_size_ > 0) {
     // Check for overflow.
     int32_t max_delta_window_size =
         std::numeric_limits<int32_t>::max() - send_window_size_;
     if (delta_window_size > max_delta_window_size) {
-      std::string desc = SpdyStringPrintf(
+      SpdyString desc = SpdyStringPrintf(
           "Received WINDOW_UPDATE [delta: %d] for stream %d overflows "
           "send_window_size_ [current: %d]",
           delta_window_size, stream_id_, send_window_size_);
       session_->ResetStream(stream_id_, ERROR_CODE_FLOW_CONTROL_ERROR, desc);
       return;
     }
   }
 
   send_window_size_ += delta_window_size;
 
@@ skipping 109 matching lines @@
                                    base::Time response_time,
                                    base::TimeTicks recv_first_byte_time) {
   switch (response_state_) {
     case READY_FOR_HEADERS:
       // No header block has been received yet.
       DCHECK(response_headers_.empty());
 
       {
         SpdyHeaderBlock::const_iterator it = response_headers.find(":status");
         if (it == response_headers.end()) {
-          const std::string error("Response headers do not include :status.");
+          const SpdyString error("Response headers do not include :status.");
           LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
           session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
           return;
         }
 
         int status;
         if (!StringToInt(it->second, &status)) {
-          const std::string error("Cannot parse :status.");
+          const SpdyString error("Cannot parse :status.");
           LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
           session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
           return;
         }
 
         // Ignore informational headers.
         // TODO(bnc): Add support for 103 Early Hints, https://crbug.com/671310.
         if (status / 100 == 1) {
           return;
         }
       }
 
       response_state_ = READY_FOR_DATA_OR_TRAILERS;
 
       switch (type_) {
         case SPDY_BIDIRECTIONAL_STREAM:
         case SPDY_REQUEST_RESPONSE_STREAM:
           // A bidirectional stream or a request/response stream is ready for
           // the response headers only after request headers are sent.
           if (io_state_ == STATE_IDLE) {
-            const std::string error("Response received before request sent.");
+            const SpdyString error("Response received before request sent.");
             LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
             session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
             return;
           }
           break;
 
         case SPDY_PUSH_STREAM:
           // Push streams transition to a locally half-closed state upon
           // headers.  We must continue to buffer data while waiting for a call
           // to SetDelegate() (which may not ever happen).
@@ skipping 10 matching lines @@
 
       response_time_ = response_time;
       recv_first_byte_time_ = recv_first_byte_time;
       SaveResponseHeaders(response_headers);
 
       break;
 
     case READY_FOR_DATA_OR_TRAILERS:
       // Second header block is trailers.
       if (type_ == SPDY_PUSH_STREAM) {
-        const std::string error("Trailers not supported for push stream.");
+        const SpdyString error("Trailers not supported for push stream.");
         LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
         session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
         return;
       }
 
       response_state_ = TRAILERS_RECEIVED;
       delegate_->OnTrailers(response_headers);
       break;
 
     case TRAILERS_RECEIVED:
       // No further header blocks are allowed after trailers.
-      const std::string error("Header block received after trailers.");
+      const SpdyString error("Header block received after trailers.");
       LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
       session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
       break;
   }
 }
 
 void SpdyStream::OnPushPromiseHeadersReceived(SpdyHeaderBlock headers) {
   CHECK(!request_headers_valid_);
   CHECK_EQ(io_state_, STATE_IDLE);
   CHECK_EQ(type_, SPDY_PUSH_STREAM);
   DCHECK(!delegate_);
 
   io_state_ = STATE_RESERVED_REMOTE;
   request_headers_ = std::move(headers);
   request_headers_valid_ = true;
   url_from_header_block_ = GetUrlFromHeaderBlock(request_headers_);
 }
 
 void SpdyStream::OnDataReceived(std::unique_ptr<SpdyBuffer> buffer) {
   DCHECK(session_->IsStreamActive(stream_id_));
 
   if (response_state_ == READY_FOR_HEADERS) {
-    const std::string error("DATA received before headers.");
+    const SpdyString error("DATA received before headers.");
     LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
     session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
     return;
   }
 
   if (response_state_ == TRAILERS_RECEIVED && buffer) {
-    const std::string error("DATA received after trailers.");
+    const SpdyString error("DATA received after trailers.");
     LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
     session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
     return;
   }
 
   // Track our bandwidth.
   recv_bytes_ += buffer ? buffer->GetRemainingSize() : 0;
   recv_last_byte_time_ = base::TimeTicks::Now();
 
   // If we're still buffering data for a push stream, we will do the check for
@@ skipping 126 matching lines @@
   pending_send_data_->DidConsume(frame_payload_size);
   if (pending_send_data_->BytesRemaining() > 0) {
     QueueNextDataFrame();
     return ERR_IO_PENDING;
   } else {
     pending_send_data_ = NULL;
     return OK;
   }
 }
 
-void SpdyStream::LogStreamError(int status, const std::string& description) {
+void SpdyStream::LogStreamError(int status, const SpdyString& description) {
   net_log_.AddEvent(NetLogEventType::HTTP2_STREAM_ERROR,
                     base::Bind(&NetLogSpdyStreamErrorCallback, stream_id_,
                                status, &description));
 }
 
 void SpdyStream::OnClose(int status) {
   // In most cases, the stream should already be CLOSED. The exception is when a
   // SpdySession is shutting down while the stream is in an intermediate state.
   io_state_ = STATE_CLOSED;
   if (status == ERR_SPDY_RST_STREAM_NO_ERROR_RECEIVED) {
@@ skipping 11 matching lines @@
   // Unset |stream_id_| last so that the delegate can look it up.
   stream_id_ = 0;
 }
 
 void SpdyStream::Cancel() {
   // We may be called again from a delegate's OnClose().
   if (io_state_ == STATE_CLOSED)
     return;
 
   if (stream_id_ != 0) {
-    session_->ResetStream(stream_id_, ERROR_CODE_CANCEL, std::string());
+    session_->ResetStream(stream_id_, ERROR_CODE_CANCEL, SpdyString());
   } else {
     session_->CloseCreatedStream(GetWeakPtr(), ERROR_CODE_CANCEL);
   }
   // |this| is invalid at this point.
 }
 
 void SpdyStream::Close() {
   // We may be called again from a delegate's OnClose().
   if (io_state_ == STATE_CLOSED)
     return;
@@ skipping 221 matching lines @@
   // the delegate gets attached to the stream.
   if (delegate_)
     delegate_->OnHeadersReceived(response_headers_);
 }
 
 #define STATE_CASE(s)                                     \
   case s:                                                 \
     description = SpdyStringPrintf("%s (0x%08X)", #s, s); \
     break
 
-std::string SpdyStream::DescribeState(State state) {
-  std::string description;
+SpdyString SpdyStream::DescribeState(State state) {
+  SpdyString description;
   switch (state) {
     STATE_CASE(STATE_IDLE);
     STATE_CASE(STATE_OPEN);
     STATE_CASE(STATE_HALF_CLOSED_LOCAL_UNCLAIMED);
     STATE_CASE(STATE_HALF_CLOSED_LOCAL);
     STATE_CASE(STATE_CLOSED);
     default:
       description = SpdyStringPrintf("Unknown state 0x%08X (%u)", state, state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net