Remove net::BidirectionalStream::Cancel

net/quic/chromium/bidirectional_stream_quic_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/quic/chromium/bidirectional_stream_quic_impl.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/memory/ptr_util.h"
@@ skipping 51 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),
+        next_proto_(kProtoUnknown),
+        received_bytes_(0),
+        sent_bytes_(0),
         error_(OK),
         on_data_read_count_(0),
         on_data_sent_count_(0),
         not_expect_callback_(false),
         on_failed_called_(false),
         send_request_headers_automatically_(true),
         is_ready_(false) {
     loop_.reset(new base::RunLoop);
   }
 
@@ skipping 91 matching lines @@
     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);
     if (rv == ERR_IO_PENDING)
       callback_ = callback;
     return rv;
   }
 
-  // Cancels |stream_|.
-  void CancelStream() { stream_->Cancel(); }
-
-  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_;
+  }
 
   void DoNotSendRequestHeadersAutomatically() {
     send_request_headers_automatically_ = false;
   }
 
+  // Deletes |stream_|.
+  void DeleteStream() {
+    next_proto_ = stream_->GetProtocol();
+    received_bytes_ = stream_->GetTotalReceivedBytes();
+    sent_bytes_ = stream_->GetTotalSentBytes();
+    stream_.reset();
+  }
+
   // 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_; }
   bool on_failed_called() const { return on_failed_called_; }
   bool is_ready() const { return is_ready_; }
 
  protected:
   // Quits |loop_|.
   void QuitLoop() { loop_->Quit(); }
 
-  // Deletes |stream_|.
-  void DeleteStream() { stream_.reset(); }
-
  private:
   std::unique_ptr<BidirectionalStreamQuicImpl> 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_;
   // This is to ensure that delegate callback is not invoked synchronously when
   // calling into |stream_|.
   bool not_expect_callback_;
   bool on_failed_called_;
   CompletionCallback callback_;
   bool send_request_headers_automatically_;
   bool is_ready_;
@@ skipping 1102 matching lines @@
               IsError(ERR_QUIC_PROTOCOL_ERROR));
   EXPECT_THAT(delegate->error(), IsError(ERR_QUIC_PROTOCOL_ERROR));
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
 }
 
-TEST_P(BidirectionalStreamQuicImplTest, CancelStreamAfterSendData) {
-  SetRequest("POST", "/", DEFAULT_PRIORITY);
-  size_t spdy_request_headers_frame_length;
-  AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY,
-                                         &spdy_request_headers_frame_length));
-  AddWrite(ConstructAckAndDataPacket(2, !kIncludeVersion, 2, 1, !kFin, 0,
-                                     kUploadData, &client_maker_));
-  AddWrite(ConstructRstStreamCancelledPacket(3, strlen(kUploadData),
-                                             &client_maker_));
-
-  Initialize();
-
-  BidirectionalStreamRequestInfo request;
-  request.method = "POST";
-  request.url = GURL("http://www.google.com/");
-  request.end_stream_on_headers = false;
-  request.priority = DEFAULT_PRIORITY;
-
-  scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
-  std::unique_ptr<TestDelegateBase> delegate(
-      new TestDelegateBase(read_buffer.get(), kReadBufferSize));
-  delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
-  ConfirmHandshake();
-  delegate->WaitUntilNextCallback();  // OnStreamReady
-
-  // Server acks the request.
-  ProcessPacket(ConstructServerAckPacket(1, 0, 0));
-
-  // Server sends the response headers.
-  SpdyHeaderBlock response_headers = ConstructResponseHeaders("200");
-  size_t spdy_response_headers_frame_length;
-  ProcessPacket(
-      ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
-                                     &spdy_response_headers_frame_length, 0));
-
-  delegate->WaitUntilNextCallback();  // OnHeadersReceived
-  EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
-
-  // Send a DATA frame.
-  scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(kUploadData));
-
-  delegate->SendData(buf, buf->size(), false);
-  delegate->WaitUntilNextCallback();  // OnDataSent
-
-  delegate->CancelStream();
-  base::RunLoop().RunUntilIdle();
-
-  // Try to send data after Cancel(), should not get called back.
-  delegate->SendData(buf, buf->size(), false);
-  base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(delegate->on_failed_called());
-
-  EXPECT_EQ(0, delegate->on_data_read_count());
-  EXPECT_EQ(1, delegate->on_data_sent_count());
-  EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
-  EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length +
-                                 strlen(kUploadData)),
-            delegate->GetTotalSentBytes());
-  EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
-            delegate->GetTotalReceivedBytes());
-}
-
 TEST_P(BidirectionalStreamQuicImplTest, SessionClosedBeforeReadData) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY,
                                          &spdy_request_headers_frame_length));
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/");
@@ skipping 37 matching lines @@
   EXPECT_THAT(delegate->error(), IsError(ERR_UNEXPECTED));
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
 }
 
-TEST_P(BidirectionalStreamQuicImplTest, CancelStreamAfterReadData) {
+TEST_P(BidirectionalStreamQuicImplTest, DeleteStreamAfterReadData) {
   SetRequest("POST", "/", DEFAULT_PRIORITY);
   size_t spdy_request_headers_frame_length;
   AddWrite(ConstructRequestHeadersPacket(1, !kFin, DEFAULT_PRIORITY,
                                          &spdy_request_headers_frame_length));
   AddWrite(ConstructClientAckAndRstStreamPacket(2, 2, 1, 1));
 
   Initialize();
 
   BidirectionalStreamRequestInfo request;
   request.method = "POST";
@@ skipping 17 matching lines @@
   ProcessPacket(
       ConstructResponseHeadersPacket(2, !kFin, std::move(response_headers),
                                      &spdy_response_headers_frame_length, 0));
 
   delegate->WaitUntilNextCallback();  // OnHeadersReceived
   EXPECT_EQ("200", delegate->response_headers().find(":status")->second);
 
   // Cancel the stream after ReadData returns ERR_IO_PENDING.
   TestCompletionCallback cb;
   EXPECT_THAT(delegate->ReadData(cb.callback()), IsError(ERR_IO_PENDING));
-  delegate->CancelStream();
+  delegate->DeleteStream();
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
   EXPECT_EQ(kProtoQUIC1SPDY3, delegate->GetProtocol());
   EXPECT_EQ(static_cast<int64_t>(spdy_request_headers_frame_length),
             delegate->GetTotalSentBytes());
   EXPECT_EQ(static_cast<int64_t>(spdy_response_headers_frame_length),
             delegate->GetTotalReceivedBytes());
@@ skipping 158 matching lines @@
 
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net