Remove net::BidirectionalStream::Cancel

net/http/bidirectional_stream_unittest.cc

 // Copyright 2015 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/http/bidirectional_stream.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 41 matching lines @@
                          read_buf_len,
                          base::WrapUnique(new base::Timer(false, false))) {}
 
   TestDelegateBase(IOBuffer* read_buf,
                    int read_buf_len,
                    std::unique_ptr<base::Timer> timer)
       : read_buf_(read_buf),
         read_buf_len_(read_buf_len),
         timer_(std::move(timer)),
         loop_(nullptr),
+        received_bytes_(0),
+        sent_bytes_(0),
         error_(OK),
         on_data_read_count_(0),
         on_data_sent_count_(0),
         do_not_start_read_(false),
         run_until_completion_(false),
         not_expect_callback_(false) {}
 
   ~TestDelegateBase() override {}
 
   void OnStreamReady(bool request_headers_sent) override {
     // Request headers should always be sent in H2's case, because the
     // functionality to combine header frame with data frames is not
     // implemented.
     EXPECT_TRUE(request_headers_sent);
     if (callback_.is_null())
       return;
     callback_.Run(OK);
   }
 
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     CHECK(!not_expect_callback_);
 
     response_headers_ = response_headers.Clone();
+
     if (!do_not_start_read_)
       StartOrContinueReading();
   }
 
   void OnDataRead(int bytes_read) override {
     CHECK(!not_expect_callback_);
 
     ++on_data_read_count_;
     CHECK_GE(bytes_read, OK);
     data_received_.append(read_buf_->data(), bytes_read);
@@ skipping 73 matching lines @@
   // Calls ReadData on the |stream_| and updates internal states.
   int ReadData() {
     not_expect_callback_ = true;
     int rv = stream_->ReadData(read_buf_.get(), read_buf_len_);
     not_expect_callback_ = false;
     if (rv > 0)
       data_received_.append(read_buf_->data(), rv);
     return rv;
   }
 
-  // Cancels |stream_|.
-  void CancelStream() { stream_->Cancel(); }
+  // Deletes |stream_|.
+  void DeleteStream() {
+    next_proto_ = stream_->GetProtocol();
+    received_bytes_ = stream_->GetTotalReceivedBytes();
+    sent_bytes_ = stream_->GetTotalSentBytes();
+    stream_.reset();
+  }
 
-  // Deletes |stream_|.
-  void DeleteStream() { stream_.reset(); }
-
-  NextProto GetProtocol() const { return stream_->GetProtocol(); }
+  NextProto GetProtocol() const {
+    if (stream_)
+      return stream_->GetProtocol();
+    return next_proto_;
+  }
 
   int64_t GetTotalReceivedBytes() const {
-    return stream_->GetTotalReceivedBytes();
+    if (stream_)
+      return stream_->GetTotalReceivedBytes();
+    return received_bytes_;
   }
 
-  int64_t GetTotalSentBytes() const { return stream_->GetTotalSentBytes(); }
+  int64_t GetTotalSentBytes() const {
+    if (stream_)
+      return stream_->GetTotalSentBytes();
+    return sent_bytes_;
+  }
 
   // Const getters for internal states.
   const std::string& data_received() const { return data_received_; }
   int error() const { return error_; }
   const SpdyHeaderBlock& response_headers() const { return response_headers_; }
   const SpdyHeaderBlock& trailers() const { return trailers_; }
   int on_data_read_count() const { return on_data_read_count_; }
   int on_data_sent_count() const { return on_data_sent_count_; }
 
   // Sets whether the delegate should automatically start reading.
@@ skipping 12 matching lines @@
 
  private:
   std::unique_ptr<BidirectionalStream> stream_;
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
   std::unique_ptr<base::Timer> timer_;
   std::string data_received_;
   std::unique_ptr<base::RunLoop> loop_;
   SpdyHeaderBlock response_headers_;
   SpdyHeaderBlock trailers_;
+  NextProto next_proto_;
+  int64_t received_bytes_;
+  int64_t sent_bytes_;
   int error_;
   int on_data_read_count_;
   int on_data_sent_count_;
   bool do_not_start_read_;
   bool run_until_completion_;
   // This is to ensure that delegate callback is not invoked synchronously when
   // calling into |stream_|.
   bool not_expect_callback_;
 
   CompletionCallback callback_;
   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
 };
 
 // A delegate that deletes the stream in a particular callback.
-class CancelOrDeleteStreamDelegate : public TestDelegateBase {
+class DeleteStreamDelegate : public TestDelegateBase {
  public:
   // Specifies in which callback the stream can be deleted.
   enum Phase {
     ON_HEADERS_RECEIVED,
     ON_DATA_READ,
     ON_TRAILERS_RECEIVED,
     ON_FAILED,
   };
 
-  CancelOrDeleteStreamDelegate(IOBuffer* buf,
-                               int buf_len,
-                               Phase phase,
-                               bool do_cancel)
-      : TestDelegateBase(buf, buf_len), phase_(phase), do_cancel_(do_cancel) {}
-  ~CancelOrDeleteStreamDelegate() override {}
+  DeleteStreamDelegate(IOBuffer* buf, int buf_len, Phase phase)
+      : TestDelegateBase(buf, buf_len), phase_(phase) {}
+  ~DeleteStreamDelegate() override {}
 
   void OnHeadersReceived(const SpdyHeaderBlock& response_headers) override {
     TestDelegateBase::OnHeadersReceived(response_headers);
     if (phase_ == ON_HEADERS_RECEIVED) {
-      CancelOrDelete();
+      DeleteStream();
       QuitLoop();
     }
   }
 
   void OnDataSent() override { NOTREACHED(); }
 
   void OnDataRead(int bytes_read) override {
     if (phase_ == ON_HEADERS_RECEIVED) {
       NOTREACHED();
       return;
     }
     TestDelegateBase::OnDataRead(bytes_read);
     if (phase_ == ON_DATA_READ) {
-      CancelOrDelete();
+      DeleteStream();
       QuitLoop();
     }
   }
 
   void OnTrailersReceived(const SpdyHeaderBlock& trailers) override {
     if (phase_ == ON_HEADERS_RECEIVED || phase_ == ON_DATA_READ) {
       NOTREACHED();
       return;
     }
     TestDelegateBase::OnTrailersReceived(trailers);
     if (phase_ == ON_TRAILERS_RECEIVED) {
-      CancelOrDelete();
+      DeleteStream();
       QuitLoop();
     }
   }
 
   void OnFailed(int error) override {
     if (phase_ != ON_FAILED) {
       NOTREACHED();
       return;
     }
     TestDelegateBase::OnFailed(error);
-    CancelOrDelete();
+    DeleteStream();
     QuitLoop();
   }
 
  private:
-  void CancelOrDelete() {
-    if (do_cancel_) {
-      CancelStream();
-    } else {
-      DeleteStream();
-    }
-  }
-
   // Indicates in which callback the delegate should cancel or delete the
   // stream.
   Phase phase_;
-  // Indicates whether to cancel or delete the stream.
-  bool do_cancel_;
 
-  DISALLOW_COPY_AND_ASSIGN(CancelOrDeleteStreamDelegate);
+  DISALLOW_COPY_AND_ASSIGN(DeleteStreamDelegate);
 };
 
 // A Timer that does not start a delayed task unless the timer is fired.
 class MockTimer : public base::MockTimer {
  public:
   MockTimer() : base::MockTimer(false, false) {}
   ~MockTimer() override {}
 
   void Start(const tracked_objects::Location& posted_from,
              base::TimeDelta delay,
@@ skipping 733 matching lines @@
   EXPECT_EQ("header-value", response_headers.find("header-name")->second);
   EXPECT_EQ("bar", delegate->trailers().find("foo")->second);
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 }
 
-TEST_F(BidirectionalStreamTest, CancelStreamAfterSendData) {
+TEST_F(BidirectionalStreamTest, DeleteStreamAfterSendData) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
   SpdySerializedFrame data_frame(spdy_util_.ConstructSpdyDataFrame(
       1, kBodyData, kBodyDataSize, /*fin=*/false));
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(data_frame, 3),
       CreateMockWrite(rst, 5),
@@ skipping 28 matching lines @@
   // Send the request and receive response headers.
   sequenced_data_->RunUntilPaused();
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
 
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(
       new StringIOBuffer(std::string(kBodyData, kBodyDataSize)));
   delegate->SendData(buf, buf->size(), false);
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
-  // Cancel the stream.
-  delegate->CancelStream();
+
+  delegate->DeleteStream();
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
   EXPECT_EQ(0, delegate->on_data_read_count());
-  // EXPECT_EQ(1, delegate->on_data_send_count());
   // OnDataSent may or may not have been invoked.
-  // Calling after stream is canceled gives kProtoUnknown.
-  EXPECT_EQ(kProtoUnknown, delegate->GetProtocol());
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
+  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
+  // Bytes sent excludes the RST frame.
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes) - 1),
+            delegate->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            delegate->GetTotalReceivedBytes());
 }
 
-TEST_F(BidirectionalStreamTest, CancelStreamDuringReadData) {
+TEST_F(BidirectionalStreamTest, DeleteStreamDuringReadData) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kBodyDataSize * 3, LOWEST, nullptr, 0));
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
 
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(rst, 4),
   };
 
   SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
@@ skipping 18 matching lines @@
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   std::unique_ptr<TestDelegateBase> delegate(
       new TestDelegateBase(read_buffer.get(), kReadBufferSize));
   delegate->set_do_not_start_read(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Send the request and receive response headers.
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
-  // Cancel the stream after ReadData returns ERR_IO_PENDING.
+  // Delete the stream after ReadData returns ERR_IO_PENDING.
   int rv = delegate->ReadData();
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   EXPECT_THAT(rv, IsError(ERR_IO_PENDING));
-  delegate->CancelStream();
+  delegate->DeleteStream();
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
-  // Calling after stream is canceled gives kProtoUnknown.
-  EXPECT_EQ(kProtoUnknown, delegate->GetProtocol());
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
+  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
+  // Bytes sent excludes the RST frame.
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes) - 1),
+            delegate->GetTotalSentBytes());
+  // Response body frame isn't read becase stream is deleted once read returns
+  // ERR_IO_PENDING.
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads) - 2),
+            delegate->GetTotalReceivedBytes());
 }
 
 // Receiving a header with uppercase ASCII will result in a protocol error,
 // which should be propagated via Delegate::OnFailed.
 TEST_F(BidirectionalStreamTest, PropagateProtocolError) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyPost(
       kDefaultUrl, 1, kBodyDataSize * 3, LOW, nullptr, 0));
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
 
@@ skipping 50 matching lines @@
 
   index = ExpectLogContainsSomewhere(entries, index,
                                      NetLog::TYPE_BIDIRECTIONAL_STREAM_FAILED,
                                      NetLog::PHASE_NONE);
   entry = entries[index];
   int net_error = OK;
   EXPECT_TRUE(entry.params->GetInteger("net_error", &net_error));
   EXPECT_THAT(net_error, IsError(ERR_SPDY_PROTOCOL_ERROR));
 }
 
-INSTANTIATE_TEST_CASE_P(CancelOrDeleteTests,
-                        BidirectionalStreamTest,
-                        ::testing::Values(true, false));
-
-TEST_P(BidirectionalStreamTest, CancelOrDeleteStreamDuringOnHeadersReceived) {
+TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnHeadersReceived) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
 
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(rst, 2),
   };
 
   const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
 
   SpdySerializedFrame resp(
       spdy_util_.ConstructSpdyGetReply(kExtraResponseHeaders, 1, 1));
 
   MockRead reads[] = {
       CreateMockRead(resp, 1), MockRead(ASYNC, 0, 3),
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   std::unique_ptr<BidirectionalStreamRequestInfo> request_info(
       new BidirectionalStreamRequestInfo);
   request_info->method = "GET";
   request_info->url = default_url_;
   request_info->priority = LOWEST;
   request_info->end_stream_on_headers = true;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
-  std::unique_ptr<CancelOrDeleteStreamDelegate> delegate(
-      new CancelOrDeleteStreamDelegate(
-          read_buffer.get(), kReadBufferSize,
-          CancelOrDeleteStreamDelegate::Phase::ON_HEADERS_RECEIVED,
-          GetParam()));
+  std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
+      read_buffer.get(), kReadBufferSize,
+      DeleteStreamDelegate::Phase::ON_HEADERS_RECEIVED));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Makes sure delegate does not get called.
   base::RunLoop().RunUntilIdle();
   const SpdyHeaderBlock& response_headers = delegate->response_headers();
   EXPECT_EQ("200", response_headers.find(":status")->second);
   EXPECT_EQ("header-value", response_headers.find("header-name")->second);
   EXPECT_EQ(0u, delegate->data_received().size());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(0, delegate->on_data_read_count());
 
-  // If stream is destroyed, do not call into stream.
-  if (!GetParam())
-    return;
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
-  EXPECT_EQ(kProtoUnknown, delegate->GetProtocol());
+  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
+  // Bytes sent excludes the RST frame.
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes) - 1),
+            delegate->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            delegate->GetTotalReceivedBytes());
 }
 
-TEST_P(BidirectionalStreamTest, CancelOrDeleteStreamDuringOnDataRead) {
+TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnDataRead) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
 
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(rst, 3),
   };
 
   const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
 
@@ skipping 11 matching lines @@
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   std::unique_ptr<BidirectionalStreamRequestInfo> request_info(
       new BidirectionalStreamRequestInfo);
   request_info->method = "GET";
   request_info->url = default_url_;
   request_info->priority = LOWEST;
   request_info->end_stream_on_headers = true;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
-  std::unique_ptr<CancelOrDeleteStreamDelegate> delegate(
-      new CancelOrDeleteStreamDelegate(
-          read_buffer.get(), kReadBufferSize,
-          CancelOrDeleteStreamDelegate::Phase::ON_DATA_READ, GetParam()));
+  std::unique_ptr<DeleteStreamDelegate> delegate(
+      new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
+                               DeleteStreamDelegate::Phase::ON_DATA_READ));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Makes sure delegate does not get called.
   base::RunLoop().RunUntilIdle();
   const SpdyHeaderBlock& response_headers = delegate->response_headers();
   EXPECT_EQ("200", response_headers.find(":status")->second);
   EXPECT_EQ("header-value", response_headers.find("header-name")->second);
   EXPECT_EQ(kUploadDataSize * 1,
             static_cast<int>(delegate->data_received().size()));
   EXPECT_EQ(0, delegate->on_data_sent_count());
 
-  // If stream is destroyed, do not call into stream.
-  if (!GetParam())
-    return;
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
-  EXPECT_EQ(kProtoUnknown, delegate->GetProtocol());
+  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
+  // Bytes sent excludes the RST frame.
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes) - 1),
+            delegate->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            delegate->GetTotalReceivedBytes());
 }
 
-TEST_P(BidirectionalStreamTest, CancelOrDeleteStreamDuringOnTrailersReceived) {
+TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnTrailersReceived) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
 
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(rst, 4),
   };
 
   const char* const kExtraResponseHeaders[] = {"header-name", "header-value"};
 
@@ skipping 16 matching lines @@
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   std::unique_ptr<BidirectionalStreamRequestInfo> request_info(
       new BidirectionalStreamRequestInfo);
   request_info->method = "GET";
   request_info->url = default_url_;
   request_info->priority = LOWEST;
   request_info->end_stream_on_headers = true;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
-  std::unique_ptr<CancelOrDeleteStreamDelegate> delegate(
-      new CancelOrDeleteStreamDelegate(
-          read_buffer.get(), kReadBufferSize,
-          CancelOrDeleteStreamDelegate::Phase::ON_TRAILERS_RECEIVED,
-          GetParam()));
+  std::unique_ptr<DeleteStreamDelegate> delegate(new DeleteStreamDelegate(
+      read_buffer.get(), kReadBufferSize,
+      DeleteStreamDelegate::Phase::ON_TRAILERS_RECEIVED));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Makes sure delegate does not get called.
   base::RunLoop().RunUntilIdle();
   const SpdyHeaderBlock& response_headers = delegate->response_headers();
   EXPECT_EQ("200", response_headers.find(":status")->second);
   EXPECT_EQ("header-value", response_headers.find("header-name")->second);
   EXPECT_EQ("bar", delegate->trailers().find("foo")->second);
   EXPECT_EQ(0, delegate->on_data_sent_count());
   // OnDataRead may or may not have been fired before the stream is
-  // canceled/deleted.
-
-  // If stream is destroyed, do not call into stream.
-  if (!GetParam())
-    return;
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
-  EXPECT_EQ(kProtoUnknown, delegate->GetProtocol());
+  // deleted.
+  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
+  // Bytes sent excludes the RST frame.
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes) - 1),
+            delegate->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            delegate->GetTotalReceivedBytes());
 }
 
-TEST_P(BidirectionalStreamTest, CancelOrDeleteStreamDuringOnFailed) {
+TEST_F(BidirectionalStreamTest, DeleteStreamDuringOnFailed) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
 
   SpdySerializedFrame rst(
       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
 
   MockWrite writes[] = {
       CreateMockWrite(req, 0), CreateMockWrite(rst, 2),
   };
 
   const char* const kExtraHeaders[] = {"X-UpperCase", "yes"};
   SpdySerializedFrame resp(
       spdy_util_.ConstructSpdyGetReply(kExtraHeaders, 1, 1));
 
   MockRead reads[] = {
       CreateMockRead(resp, 1), MockRead(ASYNC, 0, 3),
   };
 
   InitSession(reads, arraysize(reads), writes, arraysize(writes));
 
   std::unique_ptr<BidirectionalStreamRequestInfo> request_info(
       new BidirectionalStreamRequestInfo);
   request_info->method = "GET";
   request_info->url = default_url_;
   request_info->priority = LOWEST;
   request_info->end_stream_on_headers = true;
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
-  std::unique_ptr<CancelOrDeleteStreamDelegate> delegate(
-      new CancelOrDeleteStreamDelegate(
-          read_buffer.get(), kReadBufferSize,
-          CancelOrDeleteStreamDelegate::Phase::ON_FAILED, GetParam()));
+  std::unique_ptr<DeleteStreamDelegate> delegate(
+      new DeleteStreamDelegate(read_buffer.get(), kReadBufferSize,
+                               DeleteStreamDelegate::Phase::ON_FAILED));
   delegate->SetRunUntilCompletion(true);
   delegate->Start(std::move(request_info), http_session_.get());
   // Makes sure delegate does not get called.
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(delegate->response_headers().end(),
             delegate->response_headers().find(":status"));
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_THAT(delegate->error(), IsError(ERR_SPDY_PROTOCOL_ERROR));
 
-  // If stream is destroyed, do not call into stream.
-  if (!GetParam())
-    return;
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
-  EXPECT_EQ(kProtoUnknown, delegate->GetProtocol());
+  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
+  // Bytes sent excludes the RST frame.
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes) - 1),
+            delegate->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            delegate->GetTotalReceivedBytes());
 }
 
 TEST_F(BidirectionalStreamTest, TestHonorAlternativeServiceHeader) {
   SpdySerializedFrame req(spdy_util_.ConstructSpdyGet(kDefaultUrl, 1, LOWEST));
   // Empty DATA frame with an END_STREAM flag.
   SpdySerializedFrame end_stream(
       spdy_util_.ConstructSpdyDataFrame(1, nullptr, 0, true));
 
   MockWrite writes[] = {CreateMockWrite(req, 0)};
 
@@ skipping 45 matching lines @@
       http_session_->http_server_properties()->GetAlternativeServices(
           url::SchemeHostPort(default_url_));
   ASSERT_EQ(1u, alternative_service_vector.size());
   EXPECT_EQ(AlternateProtocolFromNextProto(kProtoQUIC1SPDY3),
             alternative_service_vector[0].protocol);
   EXPECT_EQ("www.example.org", alternative_service_vector[0].host);
   EXPECT_EQ(443, alternative_service_vector[0].port);
 }
 
 }  // namespace net