Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/spdy_framer_test.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 <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 131 matching lines @@
       LOG(FATAL);
     }
 
     void OnStreamEnd(SpdyStreamId stream_id) override { LOG(FATAL); }
 
     void OnStreamPadding(SpdyStreamId stream_id, size_t len) override {
       LOG(FATAL);
     }
 
     void OnRstStream(SpdyStreamId stream_id,
-                     SpdyRstStreamStatus status) override {
+                     SpdyErrorCode error_code) override {
       LOG(FATAL);
     }
     void OnSetting(SpdySettingsIds id, uint32_t value) override { LOG(FATAL); }
     void OnPing(SpdyPingId unique_id, bool is_ack) override { LOG(FATAL); }
     void OnSettingsEnd() override { LOG(FATAL); }
     void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                  SpdyGoAwayStatus status) override {
+                  SpdyErrorCode error_code) override {
       LOG(FATAL);
     }
 
     void OnWindowUpdate(SpdyStreamId stream_id,
                         int delta_window_size) override {
       LOG(FATAL);
     }
 
     void OnPriority(SpdyStreamId stream_id,
                     SpdyStreamId parent_stream_id,
@@ skipping 181 matching lines @@
 
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override {
     CHECK(headers_handler_ != nullptr);
     headers_ = headers_handler_->decoded_block().Clone();
     header_bytes_received_ = headers_handler_->header_bytes_parsed();
     if (end_headers) {
       headers_handler_.reset();
     }
   }
 
-  void OnRstStream(SpdyStreamId stream_id,
-                   SpdyRstStreamStatus status) override {
-    VLOG(1) << "OnRstStream(" << stream_id << ", " << status << ")";
+  void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {
+    VLOG(1) << "OnRstStream(" << stream_id << ", " << error_code << ")";
     ++fin_frame_count_;
   }
 
   void OnSetting(SpdySettingsIds id, uint32_t value) override {
     VLOG(1) << "OnSetting(" << id << ", " << std::hex << ", " << value << ")";
     ++setting_count_;
   }
 
   void OnSettingsAck() override {
     VLOG(1) << "OnSettingsAck";
     ++settings_ack_received_;
   }
 
   void OnSettingsEnd() override {
     VLOG(1) << "OnSettingsEnd";
     ++settings_ack_sent_;
   }
 
   void OnPing(SpdyPingId unique_id, bool is_ack) override {
     LOG(DFATAL) << "OnPing(" << unique_id << ", " << (is_ack ? 1 : 0) << ")";
   }
 
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyGoAwayStatus status) override {
-    VLOG(1) << "OnGoAway(" << last_accepted_stream_id << ", " << status << ")";
+                SpdyErrorCode error_code) override {
+    VLOG(1) << "OnGoAway(" << last_accepted_stream_id << ", " << error_code
+            << ")";
     ++goaway_count_;
   }
 
   void OnHeaders(SpdyStreamId stream_id,
                  bool has_priority,
                  int weight,
                  SpdyStreamId parent_stream_id,
                  bool exclusive,
                  bool fin,
                  bool end) override {
@@ skipping 601 matching lines @@
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
 // Test that if we receive a RST_STREAM with stream ID zero, we signal an error
 // (but don't crash).
 TEST_P(SpdyFramerTest, RstStreamWithStreamIdZero) {
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
-  SpdyRstStreamIR rst_stream_ir(0, RST_STREAM_PROTOCOL_ERROR);
+  SpdyRstStreamIR rst_stream_ir(0, ERROR_CODE_PROTOCOL_ERROR);
   SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream_ir));
 
   // We shouldn't have to read the whole frame before we signal an error.
   EXPECT_CALL(visitor, OnError(testing::Eq(&framer)));
   EXPECT_GT(frame.size(), framer.ProcessInput(frame.data(), frame.size()));
   EXPECT_TRUE(framer.HasError());
   EXPECT_EQ(SpdyFramer::SPDY_INVALID_STREAM_ID, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
@@ skipping 604 matching lines @@
 
   {
     const char kDescription[] = "RST_STREAM frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x01,  // Stream: 1
         0x00, 0x00, 0x00, 0x01,  //  Error: PROTOCOL_ERROR
     };
-    SpdyRstStreamIR rst_stream(1, RST_STREAM_PROTOCOL_ERROR);
+    SpdyRstStreamIR rst_stream(1, ERROR_CODE_PROTOCOL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max stream ID";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x7f, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff
         0x00, 0x00, 0x00, 0x01,  //  Error: PROTOCOL_ERROR
     };
-    SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_PROTOCOL_ERROR);
+    SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_PROTOCOL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 
   {
     const char kDescription[] = "RST_STREAM frame with max status code";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x04,        // Length: 4
         0x03,                    //   Type: RST_STREAM
         0x00,                    //  Flags: none
         0x7f, 0xff, 0xff, 0xff,  // Stream: 0x7fffffff
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
     };
-    SpdyRstStreamIR rst_stream(0x7FFFFFFF, RST_STREAM_INTERNAL_ERROR);
+    SpdyRstStreamIR rst_stream(0x7FFFFFFF, ERROR_CODE_INTERNAL_ERROR);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateSettings) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
 
   {
     const char kDescription[] = "Network byte order SETTINGS frame";
@@ skipping 106 matching lines @@
     const char kDescription[] = "GOAWAY frame";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x0a,        // Length: 10
         0x07,                    //   Type: GOAWAY
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x00, 0x00, 0x00, 0x00,  //   Last: 0
         0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
         0x47, 0x41,              // Description
     };
-    SpdyGoAwayIR goaway_ir(0, GOAWAY_NO_ERROR, "GA");
+    SpdyGoAwayIR goaway_ir(0, ERROR_CODE_NO_ERROR, "GA");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 
   {
     const char kDescription[] = "GOAWAY frame with max stream ID, status";
     const unsigned char kH2FrameData[] = {
         0x00, 0x00, 0x0a,        // Length: 10
         0x07,                    //   Type: GOAWAY
         0x00,                    //  Flags: none
         0x00, 0x00, 0x00, 0x00,  // Stream: 0
         0x7f, 0xff, 0xff, 0xff,  //   Last: 0x7fffffff
         0x00, 0x00, 0x00, 0x02,  //  Error: INTERNAL_ERROR
         0x47, 0x41,              // Description
     };
-    SpdyGoAwayIR goaway_ir(0x7FFFFFFF, GOAWAY_INTERNAL_ERROR, "GA");
+    SpdyGoAwayIR goaway_ir(0x7FFFFFFF, ERROR_CODE_INTERNAL_ERROR, "GA");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     CompareFrame(kDescription, frame, kH2FrameData, arraysize(kH2FrameData));
   }
 }
 
 TEST_P(SpdyFramerTest, CreateHeadersUncompressed) {
   SpdyFramer framer(SpdyFramer::DISABLE_COMPRESSION);
 
   {
     const char kDescription[] = "HEADERS frame, no FIN";
@@ skipping 1657 matching lines @@
                SpdyFramer::SpdyFramerErrorToString(
                    SpdyFramer::SPDY_INVALID_DATA_FRAME_FLAGS));
   EXPECT_STREQ("SPDY_INVALID_CONTROL_FRAME_FLAGS",
                SpdyFramer::SpdyFramerErrorToString(
                    SpdyFramer::SPDY_INVALID_CONTROL_FRAME_FLAGS));
   EXPECT_STREQ("UNKNOWN_ERROR",
                SpdyFramer::SpdyFramerErrorToString(SpdyFramer::LAST_ERROR));
 }
 
 TEST_P(SpdyFramerTest, StatusCodeToStringTest) {
-  EXPECT_STREQ("NO_ERROR", SpdyFramer::StatusCodeToString(RST_STREAM_NO_ERROR));
+  EXPECT_STREQ("NO_ERROR", SpdyFramer::StatusCodeToString(ERROR_CODE_NO_ERROR));
   EXPECT_STREQ("PROTOCOL_ERROR",
-               SpdyFramer::StatusCodeToString(RST_STREAM_PROTOCOL_ERROR));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_PROTOCOL_ERROR));
   EXPECT_STREQ("INTERNAL_ERROR",
-               SpdyFramer::StatusCodeToString(RST_STREAM_INTERNAL_ERROR));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_INTERNAL_ERROR));
   EXPECT_STREQ("FLOW_CONTROL_ERROR",
-               SpdyFramer::StatusCodeToString(RST_STREAM_FLOW_CONTROL_ERROR));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_FLOW_CONTROL_ERROR));
   EXPECT_STREQ("SETTINGS_TIMEOUT",
-               SpdyFramer::StatusCodeToString(RST_STREAM_SETTINGS_TIMEOUT));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_SETTINGS_TIMEOUT));
   EXPECT_STREQ("STREAM_CLOSED",
-               SpdyFramer::StatusCodeToString(RST_STREAM_STREAM_CLOSED));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_STREAM_CLOSED));
   EXPECT_STREQ("FRAME_SIZE_ERROR",
-               SpdyFramer::StatusCodeToString(RST_STREAM_FRAME_SIZE_ERROR));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_FRAME_SIZE_ERROR));
   EXPECT_STREQ("REFUSED_STREAM",
-               SpdyFramer::StatusCodeToString(RST_STREAM_REFUSED_STREAM));
-  EXPECT_STREQ("CANCEL", SpdyFramer::StatusCodeToString(RST_STREAM_CANCEL));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_REFUSED_STREAM));
+  EXPECT_STREQ("CANCEL", SpdyFramer::StatusCodeToString(ERROR_CODE_CANCEL));
   EXPECT_STREQ("COMPRESSION_ERROR",
-               SpdyFramer::StatusCodeToString(RST_STREAM_COMPRESSION_ERROR));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_COMPRESSION_ERROR));
   EXPECT_STREQ("CONNECT_ERROR",
-               SpdyFramer::StatusCodeToString(RST_STREAM_CONNECT_ERROR));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_CONNECT_ERROR));
   EXPECT_STREQ("ENHANCE_YOUR_CALM",
-               SpdyFramer::StatusCodeToString(RST_STREAM_ENHANCE_YOUR_CALM));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_ENHANCE_YOUR_CALM));
   EXPECT_STREQ("INADEQUATE_SECURITY",
-               SpdyFramer::StatusCodeToString(RST_STREAM_INADEQUATE_SECURITY));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_INADEQUATE_SECURITY));
   EXPECT_STREQ("HTTP_1_1_REQUIRED",
-               SpdyFramer::StatusCodeToString(RST_STREAM_HTTP_1_1_REQUIRED));
+               SpdyFramer::StatusCodeToString(ERROR_CODE_HTTP_1_1_REQUIRED));
 }
 
 TEST_P(SpdyFramerTest, FrameTypeToStringTest) {
   EXPECT_STREQ("DATA", SpdyFramer::FrameTypeToString(DATA));
   EXPECT_STREQ("RST_STREAM", SpdyFramer::FrameTypeToString(RST_STREAM));
   EXPECT_STREQ("SETTINGS", SpdyFramer::FrameTypeToString(SETTINGS));
   EXPECT_STREQ("PING", SpdyFramer::FrameTypeToString(PING));
   EXPECT_STREQ("GOAWAY", SpdyFramer::FrameTypeToString(GOAWAY));
   EXPECT_STREQ("HEADERS", SpdyFramer::FrameTypeToString(HEADERS));
   EXPECT_STREQ("WINDOW_UPDATE", SpdyFramer::FrameTypeToString(WINDOW_UPDATE));
@@ skipping 56 matching lines @@
 TEST_P(SpdyFramerTest, RstStreamFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
-    SpdyRstStreamIR rst_stream(13, RST_STREAM_CANCEL);
+    SpdyRstStreamIR rst_stream(13, ERROR_CODE_CANCEL);
     SpdySerializedFrame frame(framer.SerializeRstStream(rst_stream));
     SetFrameFlags(&frame, flags);
 
-    EXPECT_CALL(visitor, OnRstStream(13, RST_STREAM_CANCEL));
+    EXPECT_CALL(visitor, OnRstStream(13, ERROR_CODE_CANCEL));
 
     framer.ProcessInput(frame.data(), frame.size());
 
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
         << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, SettingsFrameFlags) {
@@ skipping 37 matching lines @@
 TEST_P(SpdyFramerTest, GoawayFrameFlags) {
   uint8_t flags = 0;
   do {
     SCOPED_TRACE(testing::Message() << "Flags " << flags << std::hex
                                     << static_cast<int>(flags));
 
     testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
     SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
     framer.set_visitor(&visitor);
 
-    SpdyGoAwayIR goaway_ir(97, GOAWAY_NO_ERROR, "test");
+    SpdyGoAwayIR goaway_ir(97, ERROR_CODE_NO_ERROR, "test");
     SpdySerializedFrame frame(framer.SerializeGoAway(goaway_ir));
     SetFrameFlags(&frame, flags);
 
-    EXPECT_CALL(visitor, OnGoAway(97, GOAWAY_NO_ERROR));
+    EXPECT_CALL(visitor, OnGoAway(97, ERROR_CODE_NO_ERROR));
 
     framer.ProcessInput(frame.data(), frame.size());
     EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
     EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
         << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
   } while (++flags != 0);
 }
 
 TEST_P(SpdyFramerTest, HeadersFrameFlags) {
   uint8_t flags = 0;
@@ skipping 201 matching lines @@
       0x03,                    //   Type: RST_STREAM
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x01,  // Stream: 1
       0x00, 0x00, 0x00, 0xff,  //  Error: 255
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
-  EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_NO_ERROR));
+  EXPECT_CALL(visitor, OnRstStream(1, ERROR_CODE_NO_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamInvalid),
                       arraysize(kH2RstStreamInvalid));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 
   framer.Reset();
 
-  EXPECT_CALL(visitor, OnRstStream(1, RST_STREAM_INTERNAL_ERROR));
+  EXPECT_CALL(visitor, OnRstStream(1, ERROR_CODE_INTERNAL_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2RstStreamNumStatusCodes),
                       arraysize(kH2RstStreamNumStatusCodes));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
 // Test handling of GOAWAY frames with out-of-bounds status code.
 TEST_P(SpdyFramerTest, GoAwayStatusBounds) {
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x0a,        // Length: 10
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0x00, 0x00, 0x00, 0x01,  //   Last: 1
       0xff, 0xff, 0xff, 0xff,  //  Error: 0xffffffff
       0x47, 0x41,              // Description
   };
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   framer.set_visitor(&visitor);
 
-  EXPECT_CALL(visitor, OnGoAway(1, GOAWAY_INTERNAL_ERROR));
+  EXPECT_CALL(visitor, OnGoAway(1, ERROR_CODE_INTERNAL_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2FrameData),
                       arraysize(kH2FrameData));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
 // Tests handling of a GOAWAY frame with out-of-bounds stream ID.
 TEST_P(SpdyFramerTest, GoAwayStreamIdBounds) {
   const unsigned char kH2FrameData[] = {
       0x00, 0x00, 0x08,        // Length: 8
       0x07,                    //   Type: GOAWAY
       0x00,                    //  Flags: none
       0x00, 0x00, 0x00, 0x00,  // Stream: 0
       0xff, 0xff, 0xff, 0xff,  //   Last: 0x7fffffff (R-bit set)
       0x00, 0x00, 0x00, 0x00,  //  Error: NO_ERROR
   };
 
   testing::StrictMock<test::MockSpdyFramerVisitor> visitor;
   SpdyFramer framer(SpdyFramer::ENABLE_COMPRESSION);
   framer.set_visitor(&visitor);
 
-  EXPECT_CALL(visitor, OnGoAway(0x7fffffff, GOAWAY_NO_ERROR));
+  EXPECT_CALL(visitor, OnGoAway(0x7fffffff, ERROR_CODE_NO_ERROR));
   framer.ProcessInput(reinterpret_cast<const char*>(kH2FrameData),
                       arraysize(kH2FrameData));
   EXPECT_EQ(SpdyFramer::SPDY_READY_FOR_FRAME, framer.state());
   EXPECT_EQ(SpdyFramer::SPDY_NO_ERROR, framer.spdy_framer_error())
       << SpdyFramer::SpdyFramerErrorToString(framer.spdy_framer_error());
 }
 
 TEST_P(SpdyFramerTest, OnBlocked) {
   const SpdyStreamId kStreamId = 0;
 
@@ skipping 390 matching lines @@
 
     EXPECT_EQ(1, visitor->data_frame_count_);
     EXPECT_EQ(strlen(four_score), static_cast<unsigned>(visitor->data_bytes_));
     EXPECT_EQ(0, visitor->headers_frame_count_);
   }
 }
 
 }  // namespace test
 
 }  // namespace net