Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/spdy_session.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_session.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 210 matching lines @@
     NetLogCaptureMode /* capture_mode */) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
   dict->SetInteger("size", size);
   dict->SetBoolean("fin", fin);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdyRstCallback(
     SpdyStreamId stream_id,
-    int status,
+    int error_code,
     const std::string* description,
     NetLogCaptureMode /* capture_mode */) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("stream_id", static_cast<int>(stream_id));
-  dict->SetInteger("status", status);
+  dict->SetInteger("error_code", error_code);
   dict->SetString("description", *description);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdyPingCallback(
     SpdyPingId unique_id,
     bool is_ack,
     const char* type,
     NetLogCaptureMode /* capture_mode */) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("unique_id", static_cast<int>(unique_id));
   dict->SetString("type", type);
   dict->SetBoolean("is_ack", is_ack);
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdyGoAwayCallback(
     SpdyStreamId last_stream_id,
     int active_streams,
     int unclaimed_streams,
-    SpdyGoAwayStatus status,
+    SpdyErrorCode error_code,
     base::StringPiece debug_data,
     NetLogCaptureMode capture_mode) {
   auto dict = base::MakeUnique<base::DictionaryValue>();
   dict->SetInteger("last_accepted_stream_id",
                    static_cast<int>(last_stream_id));
   dict->SetInteger("active_streams", active_streams);
   dict->SetInteger("unclaimed_streams", unclaimed_streams);
-  dict->SetInteger("status", static_cast<int>(status));
+  dict->SetInteger("error_code", static_cast<int>(error_code));
   dict->SetString("debug_data",
                   ElideGoAwayDebugDataForNetLog(capture_mode, debug_data));
   return std::move(dict);
 }
 
 std::unique_ptr<base::Value> NetLogSpdyPushPromiseReceivedCallback(
     const SpdyHeaderBlock* headers,
     SpdyStreamId stream_id,
     SpdyStreamId promised_stream_id,
     NetLogCaptureMode capture_mode) {
@@ skipping 170 matching lines @@
       return ERR_SPDY_FRAME_SIZE_ERROR;
     case SpdyFramer::SPDY_INVALID_STREAM_ID:
       return ERR_SPDY_PROTOCOL_ERROR;
     default:
       NOTREACHED();
       return ERR_SPDY_PROTOCOL_ERROR;
   }
 }
 
 SpdyProtocolErrorDetails MapRstStreamStatusToProtocolError(
-    SpdyRstStreamStatus status) {
-  switch (status) {
-    case RST_STREAM_NO_ERROR:
+    SpdyErrorCode error_code) {
+  switch (error_code) {
+    case ERROR_CODE_NO_ERROR:
       return STATUS_CODE_NO_ERROR;
-    case RST_STREAM_PROTOCOL_ERROR:
+    case ERROR_CODE_PROTOCOL_ERROR:
       return STATUS_CODE_PROTOCOL_ERROR;
-    case RST_STREAM_INTERNAL_ERROR:
+    case ERROR_CODE_INTERNAL_ERROR:
       return STATUS_CODE_INTERNAL_ERROR;
-    case RST_STREAM_FLOW_CONTROL_ERROR:
+    case ERROR_CODE_FLOW_CONTROL_ERROR:
       return STATUS_CODE_FLOW_CONTROL_ERROR;
-    case RST_STREAM_SETTINGS_TIMEOUT:
+    case ERROR_CODE_SETTINGS_TIMEOUT:
       return STATUS_CODE_SETTINGS_TIMEOUT;
-    case RST_STREAM_STREAM_CLOSED:
+    case ERROR_CODE_STREAM_CLOSED:
       return STATUS_CODE_STREAM_CLOSED;
-    case RST_STREAM_FRAME_SIZE_ERROR:
+    case ERROR_CODE_FRAME_SIZE_ERROR:
       return STATUS_CODE_FRAME_SIZE_ERROR;
-    case RST_STREAM_REFUSED_STREAM:
+    case ERROR_CODE_REFUSED_STREAM:
       return STATUS_CODE_REFUSED_STREAM;
-    case RST_STREAM_CANCEL:
+    case ERROR_CODE_CANCEL:
       return STATUS_CODE_CANCEL;
-    case RST_STREAM_COMPRESSION_ERROR:
+    case ERROR_CODE_COMPRESSION_ERROR:
       return STATUS_CODE_COMPRESSION_ERROR;
-    case RST_STREAM_CONNECT_ERROR:
+    case ERROR_CODE_CONNECT_ERROR:
       return STATUS_CODE_CONNECT_ERROR;
-    case RST_STREAM_ENHANCE_YOUR_CALM:
+    case ERROR_CODE_ENHANCE_YOUR_CALM:
       return STATUS_CODE_ENHANCE_YOUR_CALM;
-    case RST_STREAM_INADEQUATE_SECURITY:
+    case ERROR_CODE_INADEQUATE_SECURITY:
       return STATUS_CODE_INADEQUATE_SECURITY;
-    case RST_STREAM_HTTP_1_1_REQUIRED:
+    case ERROR_CODE_HTTP_1_1_REQUIRED:
       return STATUS_CODE_HTTP_1_1_REQUIRED;
     default:
       NOTREACHED();
       return static_cast<SpdyProtocolErrorDetails>(-1);
   }
 }
 
-SpdyGoAwayStatus MapNetErrorToGoAwayStatus(Error err) {
+SpdyErrorCode MapNetErrorToGoAwayStatus(Error err) {
   switch (err) {
     case OK:
-      return GOAWAY_NO_ERROR;
+      return ERROR_CODE_NO_ERROR;
     case ERR_SPDY_PROTOCOL_ERROR:
-      return GOAWAY_PROTOCOL_ERROR;
+      return ERROR_CODE_PROTOCOL_ERROR;
     case ERR_SPDY_FLOW_CONTROL_ERROR:
-      return GOAWAY_FLOW_CONTROL_ERROR;
+      return ERROR_CODE_FLOW_CONTROL_ERROR;
     case ERR_SPDY_FRAME_SIZE_ERROR:
-      return GOAWAY_FRAME_SIZE_ERROR;
+      return ERROR_CODE_FRAME_SIZE_ERROR;
     case ERR_SPDY_COMPRESSION_ERROR:
-      return GOAWAY_COMPRESSION_ERROR;
+      return ERROR_CODE_COMPRESSION_ERROR;
     case ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY:
-      return GOAWAY_INADEQUATE_SECURITY;
+      return ERROR_CODE_INADEQUATE_SECURITY;
     default:
-      return GOAWAY_PROTOCOL_ERROR;
+      return ERROR_CODE_PROTOCOL_ERROR;
   }
 }
 
 SpdyStreamRequest::SpdyStreamRequest() : weak_ptr_factory_(this) {
   Reset();
 }
 
 SpdyStreamRequest::~SpdyStreamRequest() {
   CancelRequest();
 }
@@ skipping 354 matching lines @@
 
 void SpdySession::CancelPush(const GURL& url) {
   UnclaimedPushedStreamContainer::const_iterator unclaimed_it =
       unclaimed_pushed_streams_.find(url);
   if (unclaimed_it == unclaimed_pushed_streams_.end())
     return;
 
   SpdyStreamId stream_id = unclaimed_it->second.stream_id;
 
   if (active_streams_.find(stream_id) == active_streams_.end()) {
-    ResetStream(stream_id, RST_STREAM_CANCEL,
+    ResetStream(stream_id, ERROR_CODE_CANCEL,
                 "Cancelled push stream with url: " + url.spec());
   }
   unclaimed_pushed_streams_.erase(unclaimed_it);
 }
 
 // {,Try}CreateStream() can be called with |in_io_loop_| set if a stream is
 // being created in response to another being closed due to received data.
 
 int SpdySession::TryCreateStream(
     const base::WeakPtr<SpdyStreamRequest>& request,
@@ skipping 356 matching lines @@
   CreatedStreamSet::iterator it = created_streams_.find(stream.get());
   if (it == created_streams_.end()) {
     NOTREACHED();
     return;
   }
 
   CloseCreatedStreamIterator(it, status);
 }
 
 void SpdySession::ResetStream(SpdyStreamId stream_id,
-                              SpdyRstStreamStatus status,
+                              SpdyErrorCode error_code,
                               const std::string& description) {
   DCHECK_NE(stream_id, 0u);
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     NOTREACHED();
     return;
   }
 
-  ResetStreamIterator(it, status, description);
+  ResetStreamIterator(it, error_code, description);
 }
 
 bool SpdySession::IsStreamActive(SpdyStreamId stream_id) const {
   return base::ContainsKey(active_streams_, stream_id);
 }
 
 LoadState SpdySession::GetLoadState() const {
   // Just report that we're idle since the session could be doing
   // many things concurrently.
   return LOAD_STATE_IDLE;
@@ skipping 34 matching lines @@
 }
 
 void SpdySession::CloseCreatedStreamIterator(CreatedStreamSet::iterator it,
                                              int status) {
   std::unique_ptr<SpdyStream> owned_stream(*it);
   created_streams_.erase(it);
   DeleteStream(std::move(owned_stream), status);
 }
 
 void SpdySession::ResetStreamIterator(ActiveStreamMap::iterator it,
-                                      SpdyRstStreamStatus status,
+                                      SpdyErrorCode error_code,
                                       const std::string& description) {
   // Send the RST_STREAM frame first as CloseActiveStreamIterator()
   // may close us.
   SpdyStreamId stream_id = it->first;
   RequestPriority priority = it->second->priority();
-  EnqueueResetStreamFrame(stream_id, priority, status, description);
+  EnqueueResetStreamFrame(stream_id, priority, error_code, description);
 
   // Removes any pending writes for the stream except for possibly an
   // in-flight one.
   CloseActiveStreamIterator(it, ERR_SPDY_PROTOCOL_ERROR);
 }
 
 void SpdySession::EnqueueResetStreamFrame(SpdyStreamId stream_id,
                                           RequestPriority priority,
-                                          SpdyRstStreamStatus status,
+                                          SpdyErrorCode error_code,
                                           const std::string& description) {
   DCHECK_NE(stream_id, 0u);
 
   net_log().AddEvent(
       NetLogEventType::HTTP2_SESSION_SEND_RST_STREAM,
-      base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));
+      base::Bind(&NetLogSpdyRstCallback, stream_id, error_code, &description));
 
   DCHECK(buffered_spdy_framer_.get());
   std::unique_ptr<SpdySerializedFrame> rst_frame(
-      buffered_spdy_framer_->CreateRstStream(stream_id, status));
+      buffered_spdy_framer_->CreateRstStream(stream_id, error_code));
 
   EnqueueSessionWrite(priority, RST_STREAM, std::move(rst_frame));
-  RecordProtocolErrorHistogram(MapRstStreamStatusToProtocolError(status));
+  RecordProtocolErrorHistogram(MapRstStreamStatusToProtocolError(error_code));
 }
 
 void SpdySession::EnqueuePriorityFrame(SpdyStreamId stream_id,
                                        SpdyStreamId dependency_id,
                                        int weight,
                                        bool exclusive) {
   net_log().AddEvent(NetLogEventType::HTTP2_STREAM_SEND_PRIORITY,
                      base::Bind(&NetLogSpdyPriorityCallback, stream_id,
                                 dependency_id, weight, exclusive));
 
@@ skipping 689 matching lines @@
 }
 
 void SpdySession::OnStreamError(SpdyStreamId stream_id,
                                 const std::string& description) {
   CHECK(in_io_loop_);
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // We still want to send a frame to reset the stream even if we
     // don't know anything about it.
-    EnqueueResetStreamFrame(
-        stream_id, IDLE, RST_STREAM_PROTOCOL_ERROR, description);
+    EnqueueResetStreamFrame(stream_id, IDLE, ERROR_CODE_PROTOCOL_ERROR,
+                            description);
     return;
   }
 
-  ResetStreamIterator(it, RST_STREAM_PROTOCOL_ERROR, description);
+  ResetStreamIterator(it, ERROR_CODE_PROTOCOL_ERROR, description);
 }
 
 void SpdySession::OnDataFrameHeader(SpdyStreamId stream_id,
                                     size_t length,
                                     bool fin) {
   CHECK(in_io_loop_);
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
 
   // By the time data comes in, the stream may already be inactive.
@@ skipping 163 matching lines @@
            streams_to_close.begin();
        to_close_it != streams_to_close.end(); ++to_close_it) {
     ActiveStreamMap::iterator active_it = active_streams_.find(*to_close_it);
     if (active_it == active_streams_.end())
       continue;
     bytes_pushed_and_unclaimed_count_ += active_it->second->recv_bytes();
 
     LogAbandonedActiveStream(active_it, ERR_INVALID_SPDY_STREAM);
     // CloseActiveStreamIterator() will remove the stream from
     // |unclaimed_pushed_streams_|.
-    ResetStreamIterator(
-        active_it, RST_STREAM_REFUSED_STREAM, "Stream not claimed.");
+    ResetStreamIterator(active_it, ERROR_CODE_REFUSED_STREAM,
+                        "Stream not claimed.");
   }
 
   next_unclaimed_push_stream_sweep_time_ = time_func_() +
       base::TimeDelta::FromSeconds(kMinPushedStreamLifetimeSeconds);
 }
 
 void SpdySession::OnHeaders(SpdyStreamId stream_id,
                             bool has_priority,
                             int weight,
                             SpdyStreamId parent_stream_id,
@@ skipping 18 matching lines @@
   SpdyStream* stream = it->second;
   CHECK_EQ(stream->stream_id(), stream_id);
 
   stream->AddRawReceivedBytes(last_compressed_frame_len_);
   last_compressed_frame_len_ = 0;
 
   if (it->second->IsReservedRemote()) {
     DCHECK_EQ(SPDY_PUSH_STREAM, stream->type());
     if (max_concurrent_pushed_streams_ &&
         num_active_pushed_streams_ >= max_concurrent_pushed_streams_) {
-      ResetStream(stream_id, RST_STREAM_REFUSED_STREAM,
+      ResetStream(stream_id, ERROR_CODE_REFUSED_STREAM,
                   "Stream concurrency limit reached.");
       return;
     }
 
     // Will be balanced in DeleteStream.
     num_active_pushed_streams_++;
   }
 
   base::Time response_time = base::Time::Now();
   base::TimeTicks recv_first_byte_time = time_func_();
@@ skipping 59 matching lines @@
   if (stream_id % 2 == 1 && stream_id > stream_hi_water_mark_)
     return false;
 
   if (stream_id % 2 == 0 && stream_id > last_accepted_push_stream_id_)
     return false;
 
   return true;
 }
 
 void SpdySession::OnRstStream(SpdyStreamId stream_id,
-                              SpdyRstStreamStatus status) {
+                              SpdyErrorCode error_code) {
   CHECK(in_io_loop_);
 
   std::string description;
   net_log().AddEvent(
       NetLogEventType::HTTP2_SESSION_RST_STREAM,
-      base::Bind(&NetLogSpdyRstCallback, stream_id, status, &description));
+      base::Bind(&NetLogSpdyRstCallback, stream_id, error_code, &description));
 
   ActiveStreamMap::iterator it = active_streams_.find(stream_id);
   if (it == active_streams_.end()) {
     // NOTE:  it may just be that the stream was cancelled.
     LOG(WARNING) << "Received RST for invalid stream" << stream_id;
     return;
   }
 
   CHECK_EQ(it->second->stream_id(), stream_id);
 
-  if (status == RST_STREAM_NO_ERROR) {
+  if (error_code == ERROR_CODE_NO_ERROR) {
     CloseActiveStreamIterator(it, ERR_SPDY_RST_STREAM_NO_ERROR_RECEIVED);
-  } else if (status == RST_STREAM_REFUSED_STREAM) {
+  } else if (error_code == ERROR_CODE_REFUSED_STREAM) {
     CloseActiveStreamIterator(it, ERR_SPDY_SERVER_REFUSED_STREAM);
-  } else if (status == RST_STREAM_HTTP_1_1_REQUIRED) {
+  } else if (error_code == ERROR_CODE_HTTP_1_1_REQUIRED) {
     // TODO(bnc): Record histogram with number of open streams capped at 50.
     it->second->LogStreamError(
         ERR_HTTP_1_1_REQUIRED,
         base::StringPrintf(
-            "SPDY session closed because of stream with status: %d", status));
+            "SPDY session closed because of stream with error_code: %d",
+            error_code));
     DoDrainSession(ERR_HTTP_1_1_REQUIRED, "HTTP_1_1_REQUIRED for stream.");
   } else {
     RecordProtocolErrorHistogram(
         PROTOCOL_ERROR_RST_STREAM_FOR_NON_ACTIVE_STREAM);
     it->second->LogStreamError(
         ERR_SPDY_PROTOCOL_ERROR,
-        base::StringPrintf("SPDY stream closed with status: %d", status));
+        base::StringPrintf("SPDY stream closed with error_code: %d",
+                           error_code));
     // TODO(mbelshe): Map from Spdy-protocol errors to something sensical.
     //                For now, it doesn't matter much - it is a protocol error.
     CloseActiveStreamIterator(it, ERR_SPDY_PROTOCOL_ERROR);
   }
 }
 
 void SpdySession::OnGoAway(SpdyStreamId last_accepted_stream_id,
-                           SpdyGoAwayStatus status,
+                           SpdyErrorCode error_code,
                            base::StringPiece debug_data) {
   CHECK(in_io_loop_);
 
-  // TODO(jgraettinger): UMA histogram on |status|.
+  // TODO(jgraettinger): UMA histogram on |error_code|.
 
   net_log_.AddEvent(
       NetLogEventType::HTTP2_SESSION_GOAWAY,
       base::Bind(&NetLogSpdyGoAwayCallback, last_accepted_stream_id,
                  active_streams_.size(), unclaimed_pushed_streams_.size(),
-                 status, debug_data));
+                 error_code, debug_data));
   MakeUnavailable();
-  if (status == GOAWAY_HTTP_1_1_REQUIRED) {
+  if (error_code == ERROR_CODE_HTTP_1_1_REQUIRED) {
     // TODO(bnc): Record histogram with number of open streams capped at 50.
     DoDrainSession(ERR_HTTP_1_1_REQUIRED, "HTTP_1_1_REQUIRED for stream.");
   } else {
     StartGoingAway(last_accepted_stream_id, ERR_ABORTED);
   }
   // This is to handle the case when we already don't have any active
   // streams (i.e., StartGoingAway() did nothing). Otherwise, we have
   // active streams and so the last one being closed will finish the
   // going away process (see DeleteStream()).
   MaybeFinishGoingAway();
@@ skipping 55 matching lines @@
     if (it == active_streams_.end()) {
       // NOTE:  it may just be that the stream was cancelled.
       LOG(WARNING) << "Received WINDOW_UPDATE for invalid stream " << stream_id;
       return;
     }
 
     SpdyStream* stream = it->second;
     CHECK_EQ(stream->stream_id(), stream_id);
 
     if (delta_window_size < 1) {
-      ResetStreamIterator(it, RST_STREAM_FLOW_CONTROL_ERROR,
-                          base::StringPrintf(
-                              "Received WINDOW_UPDATE with an invalid "
-                              "delta_window_size %d",
-                              delta_window_size));
+      ResetStreamIterator(
+          it, ERROR_CODE_FLOW_CONTROL_ERROR,
+          base::StringPrintf("Received WINDOW_UPDATE with an invalid "
+                             "delta_window_size %d",
+                             delta_window_size));
       return;
     }
 
     CHECK_EQ(it->second->stream_id(), stream_id);
     it->second->IncreaseSendWindowSize(delta_window_size);
   }
 }
 
 void SpdySession::TryCreatePushStream(SpdyStreamId stream_id,
                                       SpdyStreamId associated_stream_id,
@@ skipping 30 matching lines @@
   }
 
   last_accepted_push_stream_id_ = stream_id;
 
   // Pushed streams are speculative, so they start at an IDLE priority.
   const RequestPriority request_priority = IDLE;
 
   if (availability_state_ == STATE_GOING_AWAY) {
     // TODO(akalin): This behavior isn't in the SPDY spec, although it
     // probably should be.
-    EnqueueResetStreamFrame(stream_id,
-                            request_priority,
-                            RST_STREAM_REFUSED_STREAM,
+    EnqueueResetStreamFrame(stream_id, request_priority,
+                            ERROR_CODE_REFUSED_STREAM,
                             "push stream request received when going away");
     return;
   }
 
   if (associated_stream_id == 0) {
     // In HTTP/2 0 stream id in PUSH_PROMISE frame leads to framer error and
     // session going away. We should never get here.
     std::string description = base::StringPrintf(
         "Received invalid associated stream id %d for pushed stream %d",
         associated_stream_id,
         stream_id);
-    EnqueueResetStreamFrame(
-        stream_id, request_priority, RST_STREAM_REFUSED_STREAM, description);
+    EnqueueResetStreamFrame(stream_id, request_priority,
+                            ERROR_CODE_REFUSED_STREAM, description);
     return;
   }
 
   streams_pushed_count_++;
 
   // TODO(mbelshe): DCHECK that this is a GET method?
 
   // Verify that the response had a URL for us.
   GURL gurl = GetUrlFromHeaderBlock(headers);
   if (!gurl.is_valid()) {
-    EnqueueResetStreamFrame(stream_id,
-                            request_priority,
-                            RST_STREAM_PROTOCOL_ERROR,
+    EnqueueResetStreamFrame(stream_id, request_priority,
+                            ERROR_CODE_PROTOCOL_ERROR,
                             "Pushed stream url was invalid: " + gurl.spec());
     return;
   }
 
   // Verify we have a valid stream association.
   ActiveStreamMap::iterator associated_it =
       active_streams_.find(associated_stream_id);
   if (associated_it == active_streams_.end()) {
     EnqueueResetStreamFrame(
-        stream_id, request_priority, RST_STREAM_STREAM_CLOSED,
+        stream_id, request_priority, ERROR_CODE_STREAM_CLOSED,
         base::StringPrintf("Received push for inactive associated stream %d",
                            associated_stream_id));
     return;
   }
 
   DCHECK(gurl.is_valid());
 
   // Check that the pushed stream advertises the same origin as its associated
   // stream. Bypass this check if and only if this session is with a SPDY proxy
   // that is trusted explicitly as determined by the |proxy_delegate_| or if the
   // proxy is pushing same-origin resources.
   if (!HostPortPair::FromURL(gurl).Equals(host_port_pair())) {
     if (proxy_delegate_ &&
         proxy_delegate_->IsTrustedSpdyProxy(
             ProxyServer(ProxyServer::SCHEME_HTTPS, host_port_pair()))) {
       // Disallow pushing of HTTPS content.
       if (gurl.SchemeIs("https")) {
         EnqueueResetStreamFrame(
-            stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
+            stream_id, request_priority, ERROR_CODE_REFUSED_STREAM,
             base::StringPrintf("Rejected push of cross origin HTTPS content %d "
                                "from trusted proxy",
                                associated_stream_id));
         return;
       }
     } else {
       GURL associated_url(associated_it->second->GetUrlFromHeaders());
       if (associated_url.SchemeIs("https")) {
         SSLInfo ssl_info;
         CHECK(GetSSLInfo(&ssl_info));
         if (!gurl.SchemeIs("https") ||
             !CanPool(transport_security_state_, ssl_info, associated_url.host(),
                      gurl.host())) {
           EnqueueResetStreamFrame(
-              stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
+              stream_id, request_priority, ERROR_CODE_REFUSED_STREAM,
               base::StringPrintf("Rejected push stream %d on secure connection",
                                  associated_stream_id));
           return;
         }
       } else {
         // TODO(bnc): Change SpdyNetworkTransactionTests to use secure sockets.
         if (associated_url.GetOrigin() != gurl.GetOrigin()) {
           EnqueueResetStreamFrame(
-              stream_id, request_priority, RST_STREAM_REFUSED_STREAM,
+              stream_id, request_priority, ERROR_CODE_REFUSED_STREAM,
               base::StringPrintf(
                   "Rejected cross origin push stream %d on insecure connection",
                   associated_stream_id));
           return;
         }
       }
     }
   }
 
   // There should not be an existing pushed stream with the same path.
   UnclaimedPushedStreamContainer::const_iterator pushed_it =
       unclaimed_pushed_streams_.lower_bound(gurl);
   if (pushed_it != unclaimed_pushed_streams_.end() &&
       pushed_it->first == gurl) {
     EnqueueResetStreamFrame(
-        stream_id,
-        request_priority,
-        RST_STREAM_PROTOCOL_ERROR,
+        stream_id, request_priority, ERROR_CODE_PROTOCOL_ERROR,
         "Received duplicate pushed stream with url: " + gurl.spec());
     return;
   }
 
   std::unique_ptr<SpdyStream> stream(
       new SpdyStream(SPDY_PUSH_STREAM, GetWeakPtr(), gurl, request_priority,
                      stream_initial_send_window_size_,
                      stream_max_recv_window_size_, net_log_));
   stream->set_stream_id(stream_id);
 
@@ skipping 454 matching lines @@
     if (!queue->empty()) {
       SpdyStreamId stream_id = queue->front();
       queue->pop_front();
       return stream_id;
     }
   }
   return 0;
 }
 
 }  // namespace net