Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/buffered_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/buffered_spdy_framer.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/logging.h"
@@ skipping 129 matching lines @@
 
 void BufferedSpdyFramer::OnSettingsEnd() {
   visitor_->OnSettingsEnd();
 }
 
 void BufferedSpdyFramer::OnPing(SpdyPingId unique_id, bool is_ack) {
   visitor_->OnPing(unique_id, is_ack);
 }
 
 void BufferedSpdyFramer::OnRstStream(SpdyStreamId stream_id,
-                                     SpdyRstStreamStatus status) {
-  visitor_->OnRstStream(stream_id, status);
+                                     SpdyErrorCode error_code) {
+  visitor_->OnRstStream(stream_id, error_code);
 }
 void BufferedSpdyFramer::OnGoAway(SpdyStreamId last_accepted_stream_id,
-                                  SpdyGoAwayStatus status) {
+                                  SpdyErrorCode error_code) {
   DCHECK(!goaway_fields_);
   goaway_fields_.reset(new GoAwayFields());
   goaway_fields_->last_accepted_stream_id = last_accepted_stream_id;
-  goaway_fields_->status = status;
+  goaway_fields_->error_code = error_code;
 }
 
 bool BufferedSpdyFramer::OnGoAwayFrameData(const char* goaway_data,
                                            size_t len) {
   if (len > 0) {
     if (goaway_fields_->debug_data.size() < kGoAwayDebugDataMaxSize) {
       goaway_fields_->debug_data.append(
           goaway_data, std::min(len, kGoAwayDebugDataMaxSize -
                                          goaway_fields_->debug_data.size()));
     }
     return true;
   }
   visitor_->OnGoAway(goaway_fields_->last_accepted_stream_id,
-                     goaway_fields_->status, goaway_fields_->debug_data);
+                     goaway_fields_->error_code, goaway_fields_->debug_data);
   goaway_fields_.reset();
   return true;
 }
 
 void BufferedSpdyFramer::OnWindowUpdate(SpdyStreamId stream_id,
                                         int delta_window_size) {
   visitor_->OnWindowUpdate(stream_id, delta_window_size);
 }
 
 void BufferedSpdyFramer::OnPushPromise(SpdyStreamId stream_id,
@@ skipping 49 matching lines @@
 }
 
 bool BufferedSpdyFramer::HasError() {
   return spdy_framer_.HasError();
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdyRstStreamIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateRstStream(
     SpdyStreamId stream_id,
-    SpdyRstStreamStatus status) const {
-  SpdyRstStreamIR rst_ir(stream_id, status);
+    SpdyErrorCode error_code) const {
+  SpdyRstStreamIR rst_ir(stream_id, error_code);
   return new SpdySerializedFrame(spdy_framer_.SerializeRstStream(rst_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer
 // SpdySettingsIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateSettings(
     const SettingsMap& values) const {
   SpdySettingsIR settings_ir;
   for (SettingsMap::const_iterator it = values.begin(); it != values.end();
        ++it) {
     settings_ir.AddSetting(it->first, it->second);
   }
   return new SpdySerializedFrame(spdy_framer_.SerializeSettings(settings_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyPingIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreatePingFrame(SpdyPingId unique_id,
                                                          bool is_ack) const {
   SpdyPingIR ping_ir(unique_id);
   ping_ir.set_is_ack(is_ack);
   return new SpdySerializedFrame(spdy_framer_.SerializePing(ping_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyGoAwayIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateGoAway(
     SpdyStreamId last_accepted_stream_id,
-    SpdyGoAwayStatus status,
+    SpdyErrorCode error_code,
     base::StringPiece debug_data) const {
-  SpdyGoAwayIR go_ir(last_accepted_stream_id, status, debug_data);
+  SpdyGoAwayIR go_ir(last_accepted_stream_id, error_code, debug_data);
   return new SpdySerializedFrame(spdy_framer_.SerializeGoAway(go_ir));
 }
 
 // TODO(jgraettinger): Eliminate uses of this method (prefer SpdyHeadersIR).
 SpdySerializedFrame* BufferedSpdyFramer::CreateHeaders(
     SpdyStreamId stream_id,
     SpdyControlFlags flags,
     int weight,
     SpdyHeaderBlock headers) {
   SpdyHeadersIR headers_ir(stream_id, std::move(headers));
@@ skipping 52 matching lines @@
 }
 
 void BufferedSpdyFramer::InitHeaderStreaming(SpdyStreamId stream_id) {
   header_buffer_.clear();
   header_buffer_valid_ = true;
   header_stream_id_ = stream_id;
   DCHECK_NE(header_stream_id_, SpdyFramer::kInvalidStream);
 }
 
 }  // namespace net