Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/buffered_spdy_framer_unittest.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/buffered_spdy_framer.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 63 matching lines @@
   }
 
   void OnSettings() override {}
 
   void OnSetting(SpdySettingsIds id, uint32_t value) override {
     setting_count_++;
   }
 
   void OnPing(SpdyPingId unique_id, bool is_ack) override {}
 
-  void OnRstStream(SpdyStreamId stream_id,
-                   SpdyRstStreamStatus status) override {}
+  void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override {}
 
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyGoAwayStatus status,
+                SpdyErrorCode error_code,
                 base::StringPiece debug_data) override {
     goaway_count_++;
     goaway_last_accepted_stream_id_ = last_accepted_stream_id;
-    goaway_status_ = status;
+    goaway_error_code_ = error_code;
     goaway_debug_data_.assign(debug_data.data(), debug_data.size());
   }
 
   void OnDataFrameHeader(const SpdySerializedFrame* frame) {
     LOG(FATAL) << "Unexpected OnDataFrameHeader call.";
   }
 
   void OnRstStream(const SpdySerializedFrame& frame) {}
   void OnGoAway(const SpdySerializedFrame& frame) {}
   void OnPing(const SpdySerializedFrame& frame) {}
@@ skipping 57 matching lines @@
 
   // Header block streaming state:
   SpdyStreamId header_stream_id_;
   SpdyStreamId promised_stream_id_;
 
   // Headers from OnHeaders and OnPushPromise for verification.
   SpdyHeaderBlock headers_;
 
   // OnGoAway parameters.
   SpdyStreamId goaway_last_accepted_stream_id_;
-  SpdyGoAwayStatus goaway_status_;
+  SpdyErrorCode goaway_error_code_;
   std::string goaway_debug_data_;
 
   // OnAltSvc parameters.
   SpdyStreamId altsvc_stream_id_;
   std::string altsvc_origin_;
   SpdyAltSvcWireFormat::AlternativeServiceVector altsvc_vector_;
 };
 
 }  // namespace
 
@@ skipping 76 matching lines @@
   EXPECT_EQ(0, visitor.headers_frame_count_);
   EXPECT_EQ(1, visitor.push_promise_frame_count_);
   EXPECT_EQ(headers, visitor.headers_);
   EXPECT_EQ(1u, visitor.header_stream_id_);
   EXPECT_EQ(2u, visitor.promised_stream_id_);
 }
 
 TEST_F(BufferedSpdyFramerTest, GoAwayDebugData) {
   BufferedSpdyFramer framer;
   std::unique_ptr<SpdySerializedFrame> goaway_frame(
-      framer.CreateGoAway(2u, GOAWAY_FRAME_SIZE_ERROR, "foo"));
+      framer.CreateGoAway(2u, ERROR_CODE_FRAME_SIZE_ERROR, "foo"));
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(goaway_frame.get()->data()),
       goaway_frame.get()->size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.goaway_count_);
   EXPECT_EQ(2u, visitor.goaway_last_accepted_stream_id_);
-  EXPECT_EQ(GOAWAY_FRAME_SIZE_ERROR, visitor.goaway_status_);
+  EXPECT_EQ(ERROR_CODE_FRAME_SIZE_ERROR, visitor.goaway_error_code_);
   EXPECT_EQ("foo", visitor.goaway_debug_data_);
 }
 
 TEST_F(BufferedSpdyFramerTest, OnAltSvc) {
   const SpdyStreamId altsvc_stream_id(1);
   const char altsvc_origin[] = "https://www.example.org";
   SpdyAltSvcIR altsvc_ir(altsvc_stream_id);
   SpdyAltSvcWireFormat::AlternativeService alternative_service(
       "quic", "alternative.example.org", 443, 86400,
       SpdyAltSvcWireFormat::VersionVector());
   altsvc_ir.add_altsvc(alternative_service);
   altsvc_ir.set_origin(altsvc_origin);
   BufferedSpdyFramer framer;
   SpdySerializedFrame altsvc_frame(framer.SerializeFrame(altsvc_ir));
 
   TestBufferedSpdyVisitor visitor;
   visitor.SimulateInFramer(
       reinterpret_cast<unsigned char*>(altsvc_frame.data()),
       altsvc_frame.size());
   EXPECT_EQ(0, visitor.error_count_);
   EXPECT_EQ(1, visitor.altsvc_count_);
   EXPECT_EQ(altsvc_stream_id, visitor.altsvc_stream_id_);
   EXPECT_EQ(altsvc_origin, visitor.altsvc_origin_);
   ASSERT_EQ(1u, visitor.altsvc_vector_.size());
   EXPECT_EQ(alternative_service, visitor.altsvc_vector_[0]);
 }
 
 }  // namespace net