Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/spdy_deframer_visitor.cc

 // Copyright 2016 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_deframer_visitor.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <algorithm>
@@ skipping 133 matching lines @@
   void OnBlocked(SpdyStreamId stream_id) override;
   void OnContinuation(SpdyStreamId stream_id, bool end) override;
   SpdyHeadersHandlerInterface* OnHeaderFrameStart(
       SpdyStreamId stream_id) override;
   void OnHeaderFrameEnd(SpdyStreamId stream_id, bool end_headers) override;
   void OnDataFrameHeader(SpdyStreamId stream_id,
                          size_t length,
                          bool fin) override;
   void OnError(SpdyFramer* framer) override;
   void OnGoAway(SpdyStreamId last_accepted_stream_id,
-                SpdyGoAwayStatus status) override;
+                SpdyErrorCode error_code) override;
   bool OnGoAwayFrameData(const char* goaway_data, size_t len) override;
   void OnHeaders(SpdyStreamId stream_id,
                  bool has_priority,
                  int weight,
                  SpdyStreamId parent_stream_id,
                  bool exclusive,
                  bool fin,
                  bool end) override;
   void OnPing(SpdyPingId unique_id, bool is_ack) override;
   void OnPriority(SpdyStreamId stream_id,
                   SpdyStreamId parent_stream_id,
                   int weight,
                   bool exclusive) override;
   void OnPushPromise(SpdyStreamId stream_id,
                      SpdyStreamId promised_stream_id,
                      bool end) override;
-  void OnRstStream(SpdyStreamId stream_id, SpdyRstStreamStatus status) override;
+  void OnRstStream(SpdyStreamId stream_id, SpdyErrorCode error_code) override;
   void OnSetting(SpdySettingsIds id, uint32_t value) override;
   void OnSettings(bool clear_persisted) override;
   void OnSettingsAck() override;
   void OnSettingsEnd() override;
   void OnStreamFrameData(SpdyStreamId stream_id,
                          const char* data,
                          size_t len) override;
   void OnStreamEnd(SpdyStreamId stream_id) override;
   void OnStreamPadding(SpdyStreamId stream_id, size_t len) override;
   bool OnUnknownFrame(SpdyStreamId stream_id, uint8_t frame_type) override;
@@ skipping 85 matching lines @@
 }
 
 void SpdyTestDeframerImpl::AtGoAwayEnd() {
   DVLOG(1) << "AtDataEnd";
   CHECK_EQ(frame_type_, GOAWAY);
   CHECK(goaway_description_);
   if (goaway_description_->empty()) {
     listener_->OnGoAway(std::move(goaway_ir_));
   } else {
     listener_->OnGoAway(MakeUnique<SpdyGoAwayIR>(
-        goaway_ir_->last_good_stream_id(), goaway_ir_->status(),
+        goaway_ir_->last_good_stream_id(), goaway_ir_->error_code(),
         std::move(*goaway_description_)));
     CHECK_EQ(0u, goaway_description_->size());
   }
   goaway_description_.reset();
   goaway_ir_.reset();
   frame_type_ = UNSET;
 }
 
 void SpdyTestDeframerImpl::AtHeadersEnd() {
   DVLOG(1) << "AtDataEnd";
@@ skipping 197 matching lines @@
            << "     frame_type_: " << Http2FrameTypeToString(frame_type_);
   listener_->OnError(framer, this);
 }
 
 // Received a GOAWAY frame from the peer. The last stream id it accepted from us
 // is |last_accepted_stream_id|. |status| is a protocol defined error code.
 // The frame may also contain data. After this OnGoAwayFrameData will be called
 // for any non-zero amount of data, and after that it will be called with len==0
 // to indicate the end of the GOAWAY frame.
 void SpdyTestDeframerImpl::OnGoAway(SpdyStreamId last_good_stream_id,
-                                    SpdyGoAwayStatus status) {
+                                    SpdyErrorCode error_code) {
   DVLOG(1) << "OnGoAway last_good_stream_id: " << last_good_stream_id
-           << "     status: " << status;
+           << "     error code: " << error_code;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   frame_type_ = GOAWAY;
-  goaway_ir_ = MakeUnique<SpdyGoAwayIR>(last_good_stream_id, status, "");
+  goaway_ir_ = MakeUnique<SpdyGoAwayIR>(last_good_stream_id, error_code, "");
   goaway_description_.reset(new string());
 }
 
 // If len==0 then we've reached the end of the GOAWAY frame.
 bool SpdyTestDeframerImpl::OnGoAwayFrameData(const char* goaway_data,
                                              size_t len) {
   DVLOG(1) << "OnGoAwayFrameData";
   CHECK_EQ(frame_type_, GOAWAY) << "   frame_type_="
                                 << Http2FrameTypeToString(frame_type_);
   CHECK(goaway_description_);
@@ skipping 94 matching lines @@
 
   headers_.reset(new StringPairVector());
   headers_handler_.reset(new TestHeadersHandler());
   push_promise_ir_ =
       MakeUnique<SpdyPushPromiseIR>(stream_id, promised_stream_id);
 }
 
 // Closes the specified stream. After this the sender may still send PRIORITY
 // frames for this stream, which we can ignore.
 void SpdyTestDeframerImpl::OnRstStream(SpdyStreamId stream_id,
-                                       SpdyRstStreamStatus status) {
+                                       SpdyErrorCode error_code) {
   DVLOG(1) << "OnRstStream stream_id: " << stream_id
-           << "     status: " << status;
+           << "     error code: " << error_code;
   CHECK_EQ(frame_type_, UNSET) << "   frame_type_="
                                << Http2FrameTypeToString(frame_type_);
   CHECK_GT(stream_id, 0u);
 
-  listener_->OnRstStream(MakeUnique<SpdyRstStreamIR>(stream_id, status));
+  listener_->OnRstStream(MakeUnique<SpdyRstStreamIR>(stream_id, error_code));
 }
 
 // Called for an individual setting. There is no negotiation, the sender is
 // stating the value that the sender is using.
 void SpdyTestDeframerImpl::OnSetting(SpdySettingsIds id, uint32_t value) {
   DVLOG(1) << "OnSetting id: " << id << std::hex << "    value: " << value;
   CHECK_EQ(frame_type_, SETTINGS) << "   frame_type_="
                                   << Http2FrameTypeToString(frame_type_);
   CHECK(settings_);
   settings_->push_back(std::make_pair(id, value));
@@ skipping 401 matching lines @@
 // The SpdyFramer will not process any more data at this point.
 void DeframerCallbackCollector::OnError(SpdyFramer* framer,
                                         SpdyTestDeframer* deframer) {
   CollectedFrame cf;
   cf.error_reported = true;
   collected_frames_->push_back(std::move(cf));
 }
 
 }  // namespace test
 }  // namespace net