Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/spdy_framer.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_framer.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <cctype>
@@ skipping 385 matching lines @@
     case SPDY_INVALID_CONTROL_FRAME_FLAGS:
       return "SPDY_INVALID_CONTROL_FRAME_FLAGS";
     case SPDY_UNEXPECTED_FRAME:
       return "UNEXPECTED_FRAME";
     case SPDY_INTERNAL_FRAMER_ERROR:
       return "SPDY_INTERNAL_FRAMER_ERROR";
   }
   return "UNKNOWN_ERROR";
 }
 
 const char* SpdyFramer::StatusCodeToString(int status_code) {

[Bence, 2017/02/02 15:12:25]

This method is removed in server change 145087791, please wait for me to merge
that.

[diannahu, 2017/02/02 15:58:09]

Got it, will do! (I was wondering why I didn't see this method at HEAD. :P)

   switch (status_code) {
-    case RST_STREAM_NO_ERROR:
+    case ERROR_CODE_NO_ERROR:
       return "NO_ERROR";
-    case RST_STREAM_PROTOCOL_ERROR:
+    case ERROR_CODE_PROTOCOL_ERROR:
       return "PROTOCOL_ERROR";
-    case RST_STREAM_INTERNAL_ERROR:
+    case ERROR_CODE_INTERNAL_ERROR:
       return "INTERNAL_ERROR";
-    case RST_STREAM_FLOW_CONTROL_ERROR:
+    case ERROR_CODE_FLOW_CONTROL_ERROR:
       return "FLOW_CONTROL_ERROR";
-    case RST_STREAM_SETTINGS_TIMEOUT:
+    case ERROR_CODE_SETTINGS_TIMEOUT:
       return "SETTINGS_TIMEOUT";
-    case RST_STREAM_STREAM_CLOSED:
+    case ERROR_CODE_STREAM_CLOSED:
       return "STREAM_CLOSED";
-    case RST_STREAM_FRAME_SIZE_ERROR:
+    case ERROR_CODE_FRAME_SIZE_ERROR:
       return "FRAME_SIZE_ERROR";
-    case RST_STREAM_REFUSED_STREAM:
+    case ERROR_CODE_REFUSED_STREAM:
       return "REFUSED_STREAM";
-    case RST_STREAM_CANCEL:
+    case ERROR_CODE_CANCEL:
       return "CANCEL";
-    case RST_STREAM_COMPRESSION_ERROR:
+    case ERROR_CODE_COMPRESSION_ERROR:
       return "COMPRESSION_ERROR";
-    case RST_STREAM_CONNECT_ERROR:
+    case ERROR_CODE_CONNECT_ERROR:
       return "CONNECT_ERROR";
-    case RST_STREAM_ENHANCE_YOUR_CALM:
+    case ERROR_CODE_ENHANCE_YOUR_CALM:
       return "ENHANCE_YOUR_CALM";
-    case RST_STREAM_INADEQUATE_SECURITY:
+    case ERROR_CODE_INADEQUATE_SECURITY:
       return "INADEQUATE_SECURITY";
-    case RST_STREAM_HTTP_1_1_REQUIRED:
+    case ERROR_CODE_HTTP_1_1_REQUIRED:
       return "HTTP_1_1_REQUIRED";
   }
   return "UNKNOWN_STATUS";
 }
 
 const char* SpdyFramer::FrameTypeToString(SpdyFrameType type) {
   switch (type) {
     case DATA:
       return "DATA";
     case RST_STREAM:
@@ skipping 904 matching lines @@
                                                remaining_data_length_);
   remaining_data_length_ -= bytes_read;
   if (remaining_data_length_ == 0) {
     SpdyFrameReader reader(current_frame_buffer_.data(),
                            current_frame_buffer_.len());
     reader.Seek(GetFrameHeaderSize());  // Skip frame header.
 
     // Use frame-specific handlers.
     switch (current_frame_type_) {
       case RST_STREAM: {
-        uint32_t status_raw = RST_STREAM_NO_ERROR;
-        bool successful_read = reader.ReadUInt32(&status_raw);
+        uint32_t error_code = ERROR_CODE_NO_ERROR;
+        bool successful_read = reader.ReadUInt32(&error_code);
         DCHECK(successful_read);
         DCHECK(reader.IsDoneReading());
-        SpdyRstStreamStatus status = ParseRstStreamStatus(status_raw);
-        visitor_->OnRstStream(current_frame_stream_id_, status);
+        visitor_->OnRstStream(current_frame_stream_id_,
+                              ParseErrorCode(error_code));
       } break;
       case PING: {
         SpdyPingId id = 0;
         bool is_ack = current_frame_flags_ & PING_FLAG_ACK;
         bool successful_read = true;
         successful_read = reader.ReadUInt64(&id);
         DCHECK(successful_read);
         DCHECK(reader.IsDoneReading());
         visitor_->OnPing(id, is_ack);
       } break;
@@ skipping 59 matching lines @@
     // Do we have enough to parse the constant size GOAWAY header?
     if (current_frame_buffer_.len() == header_size) {
       // Parse out the last good stream id.
       SpdyFrameReader reader(current_frame_buffer_.data(),
                              current_frame_buffer_.len());
       reader.Seek(GetFrameHeaderSize());  // Seek past frame header.
       bool successful_read = reader.ReadUInt31(&current_frame_stream_id_);
       DCHECK(successful_read);
 
       // Parse status code.
-      uint32_t status_raw = GOAWAY_NO_ERROR;
-      successful_read = reader.ReadUInt32(&status_raw);
+      uint32_t error_code = ERROR_CODE_NO_ERROR;
+      successful_read = reader.ReadUInt32(&error_code);
       DCHECK(successful_read);
-      SpdyGoAwayStatus status = ParseGoAwayStatus(status_raw);
       // Finished parsing the GOAWAY header, call frame handler.
-      visitor_->OnGoAway(current_frame_stream_id_, status);
+      visitor_->OnGoAway(current_frame_stream_id_, ParseErrorCode(error_code));
     }
   }
 
   // Handle remaining data as opaque.
   bool processed_successfully = true;
   if (len > 0) {
     processed_successfully = visitor_->OnGoAwayFrameData(data, len);
   }
   remaining_data_length_ -= original_len;
   if (!processed_successfully) {
@@ skipping 331 matching lines @@
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeRstStream(
     const SpdyRstStreamIR& rst_stream) const {
   size_t expected_length = GetRstStreamSize();
   SpdyFrameBuilder builder(expected_length);
 
   builder.BeginNewFrame(*this, RST_STREAM, 0, rst_stream.stream_id());
 
-  builder.WriteUInt32(rst_stream.status());
+  builder.WriteUInt32(rst_stream.error_code());
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
 
 SpdySerializedFrame SpdyFramer::SerializeSettings(
     const SpdySettingsIR& settings) const {
   uint8_t flags = 0;
 
   if (settings.is_ack()) {
@@ skipping 43 matching lines @@
   size_t expected_length = GetGoAwayMinimumSize();
   expected_length += goaway.description().size();
   SpdyFrameBuilder builder(expected_length);
 
   // Serialize the GOAWAY frame.
   builder.BeginNewFrame(*this, GOAWAY, 0, 0);
 
   // GOAWAY frames specify the last good stream id.
   builder.WriteUInt32(goaway.last_good_stream_id());
 
-  // GOAWAY frames also specify the error status code.
-  builder.WriteUInt32(goaway.status());
+  // GOAWAY frames also specify the error code.
+  builder.WriteUInt32(goaway.error_code());
 
   // GOAWAY frames may also specify opaque data.
   if (!goaway.description().empty()) {
     builder.WriteBytes(goaway.description().data(),
                        goaway.description().size());
   }
 
   DCHECK_EQ(expected_length, builder.length());
   return builder.take();
 }
@@ skipping 557 matching lines @@
   builder->WriteUInt32(header_block.size());
 
   // Serialize each header.
   for (const auto& header : header_block) {
     builder->WriteStringPiece32(base::ToLowerASCII(header.first));
     builder->WriteStringPiece32(header.second);
   }
 }
 
 }  // namespace net