Remove net::BidirectionalStream::Cancel

net/spdy/bidirectional_stream_spdy_impl_unittest.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/bidirectional_stream_spdy_impl.h"
 
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
@@ skipping 32 matching lines @@
 
 class TestDelegateBase : public BidirectionalStreamImpl::Delegate {
  public:
   TestDelegateBase(base::WeakPtr<SpdySession> session,
                    IOBuffer* read_buf,
                    int read_buf_len)
       : stream_(new BidirectionalStreamSpdyImpl(session)),
         read_buf_(read_buf),
         read_buf_len_(read_buf_len),
         loop_(nullptr),
+        received_bytes_(0),
+        sent_bytes_(0),
         error_(OK),
         bytes_read_(0),
         on_data_read_count_(0),
         on_data_sent_count_(0),
         do_not_start_read_(false),
         run_until_completion_(false),
         not_expect_callback_(false),
         on_failed_called_(false) {}
 
   ~TestDelegateBase() override {}
@@ skipping 89 matching lines @@
     if (rv > 0) {
       data_received_.append(read_buf_->data(), rv);
       bytes_read_ += rv;
     }
     return rv;
   }
 
   NextProto GetProtocol() const { return stream_->GetProtocol(); }
 
   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 bytes_read() const { return bytes_read_; }
   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_; }
   bool on_failed_called() const { return on_failed_called_; }
 
   // Sets whether the delegate should automatically start reading.
   void set_do_not_start_read(bool do_not_start_read) {
     do_not_start_read_ = do_not_start_read;
   }
 
-  // Cancels |stream_|.
-  void CancelStream() { stream_->Cancel(); }
+  void DeleteStream() { stream_.reset(); }
 
  private:
   std::unique_ptr<BidirectionalStreamSpdyImpl> stream_;
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
   std::string data_received_;
   std::unique_ptr<base::RunLoop> loop_;
   SpdyHeaderBlock response_headers_;
   SpdyHeaderBlock trailers_;
+  int64_t received_bytes_;
+  int64_t sent_bytes_;
   int error_;
   int bytes_read_;
   int on_data_read_count_;
   int on_data_sent_count_;
   bool do_not_start_read_;
   bool run_until_completion_;
   bool not_expect_callback_;
   bool on_failed_called_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
@@ skipping 94 matching lines @@
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
   // BidirectionalStreamSpdyStreamJob does not count the bytes sent for |rst|
   // because it is sent after SpdyStream::Delegate::OnClose is called.
   EXPECT_EQ(CountWriteBytes(writes, 1), delegate->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             delegate->GetTotalReceivedBytes());
 }
 
-TEST_F(BidirectionalStreamSpdyImplTest, SendDataAfterCancelStream) {
-  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),
-  };
-
-  SpdySerializedFrame resp(spdy_util_.ConstructSpdyGetReply(nullptr, 0, 1));
-  SpdySerializedFrame response_body_frame(
-      spdy_util_.ConstructSpdyDataFrame(1, false));
-
-  MockRead reads[] = {
-      CreateMockRead(resp, 1),
-      MockRead(ASYNC, ERR_IO_PENDING, 2),  // Force a pause.
-      MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause.
-      MockRead(ASYNC, 0, 6),
-  };
-
-  InitSession(reads, arraysize(reads), writes, arraysize(writes));
-
-  BidirectionalStreamRequestInfo request_info;
-  request_info.method = "POST";
-  request_info.url = default_url_;
-  request_info.priority = LOWEST;
-  request_info.extra_headers.SetHeader(net::HttpRequestHeaders::kContentLength,
-                                       base::SizeTToString(kBodyDataSize * 3));
-
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
-  std::unique_ptr<TestDelegateBase> delegate(
-      new TestDelegateBase(session_, read_buffer.get(), kReadBufferSize));
-  delegate->set_do_not_start_read(true);
-  delegate->Start(&request_info, net_log_.bound());
-  // 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.get(), buf->size(), false);
-  sequenced_data_->Resume();
-  base::RunLoop().RunUntilIdle();
-  // Cancel the stream.
-  delegate->CancelStream();
-  sequenced_data_->Resume();
-  base::RunLoop().RunUntilIdle();
-
-  // Try to send data after Cancel(), should not get called back.
-  delegate->SendData(buf.get(), buf->size(), false);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(delegate->on_failed_called());
-
-  EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
-  EXPECT_EQ(0, delegate->on_data_read_count());
-  EXPECT_EQ(kProtoHTTP2, delegate->GetProtocol());
-  EXPECT_EQ(0, delegate->GetTotalSentBytes());
-  EXPECT_EQ(0, delegate->GetTotalReceivedBytes());
-}
-
 }  // namespace net