Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/spdy_protocol.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_protocol.h"
 
 #include "base/memory/ptr_util.h"
 #include "net/spdy/spdy_bug_tracker.h"
 
 namespace net {
@@ skipping 110 matching lines @@
       return true;
     case SETTINGS_MAX_HEADER_LIST_SIZE:
       *settings_id_string = "SETTINGS_MAX_HEADER_LIST_SIZE";
       return true;
   }
 
   *settings_id_string = "SETTINGS_UNKNOWN";
   return false;
 }
 
-SpdyRstStreamStatus ParseRstStreamStatus(int rst_stream_status_field) {
-  if (rst_stream_status_field < RST_STREAM_MIN ||
-      rst_stream_status_field > RST_STREAM_MAX) {
-    return RST_STREAM_INTERNAL_ERROR;
+SpdyErrorCode ParseErrorCode(uint32_t wire_error_code) {
+  if (wire_error_code > ERROR_CODE_MAX) {
+    return ERROR_CODE_INTERNAL_ERROR;
   }
 
-  return static_cast<SpdyRstStreamStatus>(rst_stream_status_field);
+  return static_cast<SpdyErrorCode>(wire_error_code);
 }
 
-SpdyGoAwayStatus ParseGoAwayStatus(int goaway_status_field) {
-  if (goaway_status_field < GOAWAY_MIN || goaway_status_field > GOAWAY_MAX) {
-    return GOAWAY_INTERNAL_ERROR;
+const char* ErrorCodeToString(SpdyErrorCode error_code) {

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

This method in only introduced in server change 145087791, please wait for me to
merge that.  (And it is only later, in 145536832, that the argument is changed
from uint32 to SpdyErrorCode.)

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

Got it, will merge after 145087791 is merged. (I actually have no idea how I
added this method. :D:) Should I keep it as uint32_t? Thanks!

[Bence, 2017/02/02 16:12:00]

It's really up to you.  You can include 145536832 in this CL if you think it's
trivial to do so.  I did it in a separate server side CL because some callers
must have been updated to use static_cast<>, and I preferred not to do too much
in a single CL.

+  switch (error_code) {
+    case ERROR_CODE_NO_ERROR:
+      return "NO_ERROR";
+    case ERROR_CODE_PROTOCOL_ERROR:
+      return "PROTOCOL_ERROR";
+    case ERROR_CODE_INTERNAL_ERROR:
+      return "INTERNAL_ERROR";
+    case ERROR_CODE_FLOW_CONTROL_ERROR:
+      return "FLOW_CONTROL_ERROR";
+    case ERROR_CODE_SETTINGS_TIMEOUT:
+      return "SETTINGS_TIMEOUT";
+    case ERROR_CODE_STREAM_CLOSED:
+      return "STREAM_CLOSED";
+    case ERROR_CODE_FRAME_SIZE_ERROR:
+      return "FRAME_SIZE_ERROR";
+    case ERROR_CODE_REFUSED_STREAM:
+      return "REFUSED_STREAM";
+    case ERROR_CODE_CANCEL:
+      return "CANCEL";
+    case ERROR_CODE_COMPRESSION_ERROR:
+      return "COMPRESSION_ERROR";
+    case ERROR_CODE_CONNECT_ERROR:
+      return "CONNECT_ERROR";
+    case ERROR_CODE_ENHANCE_YOUR_CALM:
+      return "ENHANCE_YOUR_CALM";
+    case ERROR_CODE_INADEQUATE_SECURITY:
+      return "INADEQUATE_SECURITY";
+    case ERROR_CODE_HTTP_1_1_REQUIRED:
+      return "HTTP_1_1_REQUIRED";
   }
-
-  return static_cast<SpdyGoAwayStatus>(goaway_status_field);
+  return "UNKNOWN_ERROR_CODE";
 }
 
 const char* const kHttp2Npn = "h2";
 
 SpdyFrameWithHeaderBlockIR::SpdyFrameWithHeaderBlockIR(
     SpdyStreamId stream_id,
     SpdyHeaderBlock header_block)
     : SpdyFrameWithFinIR(stream_id), header_block_(std::move(header_block)) {}
 
 SpdyFrameWithHeaderBlockIR::~SpdyFrameWithHeaderBlockIR() {}
@@ skipping 25 matching lines @@
       padded_(false),
       padding_payload_len_(0) {}
 
 SpdyDataIR::~SpdyDataIR() {}
 
 void SpdyDataIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitData(*this);
 }
 
 SpdyRstStreamIR::SpdyRstStreamIR(SpdyStreamId stream_id,
-                                 SpdyRstStreamStatus status)
+                                 SpdyErrorCode error_code)
     : SpdyFrameWithStreamIdIR(stream_id) {
-  set_status(status);
+  set_error_code(error_code);
 }
 
 SpdyRstStreamIR::~SpdyRstStreamIR() {}
 
 void SpdyRstStreamIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitRstStream(*this);
 }
 
 SpdySettingsIR::SpdySettingsIR() : is_ack_(false) {}
 
 SpdySettingsIR::~SpdySettingsIR() {}
 
 void SpdySettingsIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitSettings(*this);
 }
 
 void SpdyPingIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPing(*this);
 }
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-                           SpdyGoAwayStatus status,
+                           SpdyErrorCode error_code,
                            base::StringPiece description)
     : description_(description) {
-      set_last_good_stream_id(last_good_stream_id);
-  set_status(status);
+  set_last_good_stream_id(last_good_stream_id);
+  set_error_code(error_code);
 }
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-                           SpdyGoAwayStatus status,
+                           SpdyErrorCode error_code,
                            const char* description)
     : SpdyGoAwayIR(last_good_stream_id,
-                   status,
+                   error_code,
                    base::StringPiece(description)) {}
 
 SpdyGoAwayIR::SpdyGoAwayIR(SpdyStreamId last_good_stream_id,
-                           SpdyGoAwayStatus status,
+                           SpdyErrorCode error_code,
                            std::string description)
     : description_store_(std::move(description)),
       description_(description_store_) {
   set_last_good_stream_id(last_good_stream_id);
-  set_status(status);
+  set_error_code(error_code);
 }
 
 SpdyGoAwayIR::~SpdyGoAwayIR() {}
 
 SpdyContinuationIR::SpdyContinuationIR(SpdyStreamId stream_id)
     : SpdyFrameWithStreamIdIR(stream_id), end_headers_(false) {
   encoding_ = base::MakeUnique<std::string>();
 }
 
 SpdyContinuationIR::~SpdyContinuationIR() {}
@@ skipping 31 matching lines @@
 
 void SpdyAltSvcIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitAltSvc(*this);
 }
 
 void SpdyPriorityIR::Visit(SpdyFrameVisitor* visitor) const {
   return visitor->VisitPriority(*this);
 }
 
 }  // namespace net