Spdy{RstStream,GoAway}Status -> SpdyErrorCode.

net/spdy/spdy_http_stream_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/spdy_http_stream.h"
 
 #include <stdint.h>
 
 #include <memory>
+#include <string>
 
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "crypto/ec_private_key.h"
 #include "crypto/ec_signature_creator.h"
 #include "crypto/signature_creator.h"
 #include "net/base/chunked_upload_data_stream.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/load_timing_info_test_util.h"
@@ skipping 77 matching lines @@
 
   const FailureMode async_;
 
   base::WeakPtrFactory<ReadErrorUploadDataStream> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadErrorUploadDataStream);
 };
 
 class CancelStreamCallback : public TestCompletionCallbackBase {
  public:
-  CancelStreamCallback(SpdyHttpStream* stream)
+  explicit CancelStreamCallback(SpdyHttpStream* stream)
       : stream_(stream),
         callback_(base::Bind(&CancelStreamCallback::CancelStream,
                              base::Unretained(this))) {}
 
   const CompletionCallback& callback() const { return callback_; }
 
  private:
   void CancelStream(int result) {
     stream_->Cancel();
     SetResult(result);
@@ skipping 787 matching lines @@
                 buf1.get(), kUploadDataSize, callback.callback()));
   EXPECT_EQ(kUploadData, std::string(buf1->data(), kUploadDataSize));
 
   ASSERT_TRUE(response.headers.get());
   ASSERT_EQ(200, response.headers->response_code());
 }
 
 TEST_F(SpdyHttpStreamTest, DataReadErrorSynchronous) {
   SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
 
-  // Server receives RST_STREAM_INTERNAL_ERROR on client's internal failure.
+  // Server receives ERROR_CODE_INTERNAL_ERROR on client's internal failure.
   // The failure is a reading error in this case caused by
   // UploadDataStream::Read().
   SpdySerializedFrame rst_frame(
-      spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_INTERNAL_ERROR));
+      spdy_util_.ConstructSpdyRstStream(1, ERROR_CODE_INTERNAL_ERROR));
 
   MockWrite writes[] = {
       CreateMockWrite(req, 0, SYNCHRONOUS),       // Request
       CreateMockWrite(rst_frame, 1, SYNCHRONOUS)  // Reset frame
   };
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostReply(nullptr, 0));
 
   MockRead reads[] = {
       CreateMockRead(resp, 2), MockRead(SYNCHRONOUS, 0, 3),
@@ skipping 28 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Because the server has not closed the connection yet, there shouldn't be
   // a stream but a session in the pool
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 TEST_F(SpdyHttpStreamTest, DataReadErrorAsynchronous) {
   SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
 
-  // Server receives RST_STREAM_INTERNAL_ERROR on client's internal failure.
+  // Server receives ERROR_CODE_INTERNAL_ERROR on client's internal failure.
   // The failure is a reading error in this case caused by
   // UploadDataStream::Read().
   SpdySerializedFrame rst_frame(
-      spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_INTERNAL_ERROR));
+      spdy_util_.ConstructSpdyRstStream(1, ERROR_CODE_INTERNAL_ERROR));
 
   MockWrite writes[] = {
       CreateMockWrite(req, 0),       // Request
       CreateMockWrite(rst_frame, 1)  // Reset frame
   };
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyPostReply(nullptr, 0));
 
   MockRead reads[] = {
       MockRead(ASYNC, 0, 2),
@@ skipping 32 matching lines @@
   // in the pool anymore.
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 // Regression test for https://crbug.com/622447.
 TEST_F(SpdyHttpStreamTest, RequestCallbackCancelsStream) {
   SpdySerializedFrame req(spdy_util_.ConstructChunkedSpdyPost(nullptr, 0));
   SpdySerializedFrame chunk(
       spdy_util_.ConstructSpdyDataFrame(1, nullptr, 0, true));
   SpdySerializedFrame rst(
-      spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
+      spdy_util_.ConstructSpdyRstStream(1, ERROR_CODE_CANCEL));
   MockWrite writes[] = {CreateMockWrite(req, 0), CreateMockWrite(chunk, 1),
                         CreateMockWrite(rst, 2)};
   MockRead reads[] = {MockRead(ASYNC, 0, 3)};
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = url_;
   ChunkedUploadDataStream upload_stream(0);
   request.upload_data_stream = &upload_stream;
@@ skipping 27 matching lines @@
 
   EXPECT_FALSE(HasSpdySession(http_session_->spdy_session_pool(), key_));
 }
 
 // TODO(willchan): Write a longer test for SpdyStream that exercises all
 // methods.
 
 }  // namespace test
 
 }  // namespace net