[Cronet] Add Hello World response to QuicTestServer and use it in bidirectional stream test.

components/cronet/ios/cronet_bidirectional_stream.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 "components/cronet/ios/cronet_bidirectional_stream.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 163 matching lines @@
 void CronetBidirectionalStream::OnTrailersReceived(
     const net::SpdyHeaderBlock& response_trailers) {
   DCHECK(environment_->IsOnNetworkThread());
   delegate_->OnTrailersReceived(response_trailers);
 }
 
 void CronetBidirectionalStream::OnFailed(int error) {
   DCHECK(environment_->IsOnNetworkThread());
   bidi_stream_.reset();
   read_state_ = write_state_ = ERROR;
   delegate_->OnFailed(error);

[xunjieli, 2016/04/28 20:20:45]

Does the API guarantee that delegate is only get notified of OnFailed at most
once? If so, maybe we should null out delegate_ here.

 }
 
 void CronetBidirectionalStream::StartOnNetworkThread(
     std::unique_ptr<net::BidirectionalStreamRequestInfo> request_info) {
   DCHECK(environment_->IsOnNetworkThread());
   DCHECK(!bidi_stream_);
   DCHECK(environment_->GetURLRequestContext());
   request_info->extra_headers.SetHeaderIfMissing(
       net::HttpRequestHeaders::kUserAgent, environment_->user_agent());
   bidi_stream_.reset(new net::BidirectionalStream(
       std::move(request_info), environment_->GetURLRequestContext()
                                    ->http_transaction_factory()
                                    ->GetSession(),
       /*disable_auto_flush=*/false, this));
   DCHECK(read_state_ == NOT_STARTED && write_state_ == NOT_STARTED);
   read_state_ = write_state_ = STARTED;
 }
 
 void CronetBidirectionalStream::ReadDataOnNetworkThread(
     scoped_refptr<net::WrappedIOBuffer> read_buffer,
     int buffer_size) {
   DCHECK(environment_->IsOnNetworkThread());
   DCHECK(read_buffer);
   DCHECK(!read_buffer_);
   if (read_state_ != WAITING_FOR_READ) {
     DLOG(ERROR) << "Unexpected Read Data in read_state " << WAITING_FOR_READ;
-    OnFailed(net::ERR_UNEXPECTED);
+    // Invoke OnFailed unless it is already invoked.
+    if (read_state_ != ERROR)
+      OnFailed(net::ERR_UNEXPECTED);
     return;
   }
   read_state_ = READING;
   read_buffer_ = read_buffer;
 
   int bytes_read = bidi_stream_->ReadData(read_buffer_.get(), buffer_size);
   // If IO is pending, wait for the BidirectionalStream to call OnDataRead.
   if (bytes_read == net::ERR_IO_PENDING)
     return;
 
   if (bytes_read < 0) {
     OnFailed(bytes_read);
     return;
   }
   OnDataRead(bytes_read);
 }
 
 void CronetBidirectionalStream::WriteDataOnNetworkThread(
     scoped_refptr<net::WrappedIOBuffer> write_buffer,
     int buffer_size,
     bool end_of_stream) {
   DCHECK(environment_->IsOnNetworkThread());
   DCHECK(write_buffer);
   DCHECK(!write_buffer_);
   if (write_state_ != WAITING_FOR_WRITE) {
     DLOG(ERROR) << "Unexpected Write Data in write_state " << write_state_;
-    OnFailed(net::ERR_UNEXPECTED);
+    // Invoke OnFailed unless it is already invoked.
+    if (write_state_ != ERROR)
+      OnFailed(net::ERR_UNEXPECTED);

[xunjieli, 2016/04/28 15:23:33]

If the request has been canceled, we probably could provide ERR_ABORTED as the
better error code.

[mef, 2016/04/28 17:11:26]

That's an interesting point. I think we shouldn't invoke OnFailed at all if
stream is in one one of the terminal states (DONE, CANCELED or FAILED). WDYT?

[xunjieli, 2016/04/28 20:20:45]

I am not sure. Either approach is fine with me as long as we document it in the
API doc and be consistent. We can handle this in a follow-up, since I guess we
will end up changing the API anyway to handle flush.

     return;
   }
   write_state_ = WRITING;
   write_end_of_stream_ = end_of_stream;
 
   write_buffer_ = write_buffer;
   bidi_stream_->SendData(write_buffer_.get(), buffer_size, end_of_stream);
 }
 
 void CronetBidirectionalStream::CancelOnNetworkThread() {
@@ skipping 13 matching lines @@
 void CronetBidirectionalStream::MaybeOnSucceded() {
   DCHECK(environment_->IsOnNetworkThread());
   if (read_state_ == READING_DONE && write_state_ == WRITING_DONE) {
     read_state_ = write_state_ = SUCCESS;
     bidi_stream_.reset();
     delegate_->OnSucceeded();
   }
 }
 
 }  // namespace cronet