Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

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>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 71 matching lines @@
 
 bool ContainsUppercaseAscii(base::StringPiece str) {
   return std::any_of(str.begin(), str.end(), base::IsAsciiUpper<char>);
 }
 
 }  // namespace
 
 // A wrapper around a stream that calls into ProduceHeadersFrame().
 class SpdyStream::HeadersBufferProducer : public SpdyBufferProducer {
  public:
-  HeadersBufferProducer(const base::WeakPtr<SpdyStream>& stream)
+  explicit HeadersBufferProducer(const base::WeakPtr<SpdyStream>& stream)
       : stream_(stream) {
     DCHECK(stream_.get());
   }
 
   ~HeadersBufferProducer() override {}
 
   std::unique_ptr<SpdyBuffer> ProduceBuffer() override {
     if (!stream_.get()) {
       NOTREACHED();
       return std::unique_ptr<SpdyBuffer>();
@@ skipping 173 matching lines @@
 
   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 = base::StringPrintf(
           "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_, RST_STREAM_FLOW_CONTROL_ERROR, desc);
+      session_->ResetStream(stream_id_, ERROR_CODE_FLOW_CONTROL_ERROR, desc);
       return;
     }
   }
 
   send_window_size_ += delta_window_size;
 
   net_log_.AddEvent(
       NetLogEventType::HTTP2_STREAM_UPDATE_SEND_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
                  delta_window_size, send_window_size_));
@@ skipping 60 matching lines @@
 
 void SpdyStream::DecreaseRecvWindowSize(int32_t delta_window_size) {
   DCHECK(session_->IsStreamActive(stream_id_));
   DCHECK_GE(delta_window_size, 1);
 
   // The receiving window size as the peer knows it is
   // |recv_window_size_ - unacked_recv_window_bytes_|, if more data are sent by
   // the peer, that means that the receive window is not being respected.
   if (delta_window_size > recv_window_size_ - unacked_recv_window_bytes_) {
     session_->ResetStream(
-        stream_id_, RST_STREAM_FLOW_CONTROL_ERROR,
+        stream_id_, ERROR_CODE_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(recv_window_size_));
     return;
   }
 
   recv_window_size_ -= delta_window_size;
   net_log_.AddEvent(
       NetLogEventType::HTTP2_STREAM_UPDATE_RECV_WINDOW,
       base::Bind(&NetLogSpdyStreamWindowUpdateCallback, stream_id_,
@@ skipping 25 matching lines @@
                                    base::TimeTicks recv_first_byte_time) {
   switch (response_state_) {
     case READY_FOR_HEADERS: {
       // No header block has been received yet.
       DCHECK(response_headers_.empty());
       int status;
       switch (ParseStatusHeader(response_headers, &status)) {
         case STATUS_HEADER_NOT_INCLUDED: {
           const std::string error("Response headers do not include :status.");
           LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-          session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, error);
+          session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
           return;
         }
         case STATUS_HEADER_DOES_NOT_START_WITH_NUMBER: {
           const std::string error("Cannot parse :status.");
           LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-          session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR, error);
+          session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR, error);
           return;
         }
         // Intentional fallthrough for the following two cases,
         // to maintain compatibility with broken servers that include
         // status text in the response.
         case STATUS_HEADER_IS_NUMBER:
         case STATUS_HEADER_HAS_STATUS_TEXT:
           // 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.");
             LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-            session_->ResetStream(stream_id_, RST_STREAM_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).
           DCHECK_EQ(io_state_, STATE_RESERVED_REMOTE);
           if (!delegate_) {
@@ skipping 10 matching lines @@
       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.");
         LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-        session_->ResetStream(stream_id_, RST_STREAM_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.");
       LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-      session_->ResetStream(stream_id_, RST_STREAM_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.");
     LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-    session_->ResetStream(stream_id_, RST_STREAM_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.");
     LogStreamError(ERR_SPDY_PROTOCOL_ERROR, error);
-    session_->ResetStream(stream_id_, RST_STREAM_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
   // data received with incomplete headers in PushedStreamReplay().
   if (io_state_ == STATE_HALF_CLOSED_LOCAL_UNCLAIMED) {
@@ skipping 154 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_, RST_STREAM_CANCEL, std::string());
+    session_->ResetStream(stream_id_, ERROR_CODE_CANCEL, std::string());
   } else {
-    session_->CloseCreatedStream(GetWeakPtr(), RST_STREAM_CANCEL);
+    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;
 
   if (stream_id_ != 0) {
@@ skipping 180 matching lines @@
 
   session_->EnqueueStreamWrite(
       GetWeakPtr(), DATA,
       std::unique_ptr<SpdyBufferProducer>(
           new SimpleBufferProducer(std::move(data_buffer))));
 }
 
 void SpdyStream::SaveResponseHeaders(const SpdyHeaderBlock& response_headers) {
   DCHECK(response_headers_.empty());
   if (response_headers.find("transfer-encoding") != response_headers.end()) {
-    session_->ResetStream(stream_id_, RST_STREAM_PROTOCOL_ERROR,
-                         "Received transfer-encoding header");
+    session_->ResetStream(stream_id_, ERROR_CODE_PROTOCOL_ERROR,
+                          "Received transfer-encoding header");
     return;
   }
 
   for (SpdyHeaderBlock::const_iterator it = response_headers.begin();
        it != response_headers.end(); ++it) {
     // Disallow uppercase headers.
     if (ContainsUppercaseAscii(it->first)) {
       session_->ResetStream(
-          stream_id_, RST_STREAM_PROTOCOL_ERROR,
+          stream_id_, ERROR_CODE_PROTOCOL_ERROR,
           "Upper case characters in header: " + it->first.as_string());
       return;
     }
 
     response_headers_.insert(*it);
   }
 
   // If delegate is not yet attached, OnHeadersReceived() will be called after
   // the delegate gets attached to the stream.
   if (delegate_)
@@ skipping 17 matching lines @@
       description = base::StringPrintf("Unknown state 0x%08X (%u)", state,
                                        state);
       break;
   }
   return description;
 }
 
 #undef STATE_CASE
 
 }  // namespace net