[Cronet] Make delaying sending request headers explicit in bidirectional stream

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 "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 40 matching lines @@
                    std::unique_ptr<base::Timer> timer)
       : read_buf_(read_buf),
         read_buf_len_(read_buf_len),
         timer_(std::move(timer)),
         loop_(nullptr),
         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),
-        disable_auto_flush_(false) {}
+        not_expect_callback_(false) {}
 
   ~TestDelegateBase() override {}
 
-  void OnStreamReady() 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;
     if (!do_not_start_read_)
@@ skipping 27 matching lines @@
   void OnFailed(int error) override {
     CHECK(!not_expect_callback_);
     CHECK_EQ(OK, error_);
     CHECK_NE(OK, error);
 
     error_ = error;
     if (run_until_completion_)
       loop_->Quit();
   }
 
-  void DisableAutoFlush() { disable_auto_flush_ = true; }
-
   void Start(std::unique_ptr<BidirectionalStreamRequestInfo> request_info,
              HttpNetworkSession* session) {
     stream_.reset(new BidirectionalStream(std::move(request_info), session,
-                                          false, this, std::move(timer_)));
+                                          /*ignored*/ true, this,
+                                          std::move(timer_)));
     if (run_until_completion_)
       loop_->Run();
   }
 
   void Start(std::unique_ptr<BidirectionalStreamRequestInfo> request_info,
              HttpNetworkSession* session,
              const CompletionCallback& cb) {
     callback_ = cb;
     stream_.reset(new BidirectionalStream(std::move(request_info), session,
-                                          disable_auto_flush_, this,
+                                          /*ignored*/ true, this,
                                           std::move(timer_)));
     if (run_until_completion_)
       loop_->Run();
   }
 
+  void SendRequestHeaders() { stream_->SendRequestHeaders(); }
+
   void SendData(const scoped_refptr<IOBuffer>& data,
                 int length,
                 bool end_of_stream) {
     not_expect_callback_ = true;
     stream_->SendData(data, length, end_of_stream);
     not_expect_callback_ = false;
   }
 
   void SendvData(const std::vector<scoped_refptr<IOBuffer>>& data,
                  const std::vector<int>& length,
@@ skipping 70 matching lines @@
   SpdyHeaderBlock response_headers_;
   SpdyHeaderBlock trailers_;
   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_;
-  bool disable_auto_flush_;
 
   CompletionCallback callback_;
   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
 };
 
 // A delegate that deletes the stream in a particular callback.
 class CancelOrDeleteStreamDelegate : public TestDelegateBase {
  public:
   // Specifies in which callback the stream can be deleted.
   enum Phase {
@@ skipping 516 matching lines @@
   request_info->url = GURL("https://www.example.org/");
   request_info->priority = LOWEST;
   request_info->extra_headers.SetHeader(net::HttpRequestHeaders::kContentLength,
                                         base::SizeTToString(kBodyDataSize * 1));
 
   scoped_refptr<IOBuffer> read_buffer(new IOBuffer(kReadBufferSize));
   MockTimer* timer = new MockTimer();
   std::unique_ptr<TestDelegateBase> delegate(new TestDelegateBase(
       read_buffer.get(), kReadBufferSize, base::WrapUnique(timer)));
   delegate->set_do_not_start_read(true);
-  delegate->DisableAutoFlush();
   TestCompletionCallback callback;
   delegate->Start(std::move(request_info), http_session_.get(),
                   callback.callback());
   // Wait until the stream is ready.
   callback.WaitForResult();
+  // Sending request headers explicitly should do nothing in H2's case, and it
+  // should not crash because headers have been sent automatically.
+  delegate->SendRequestHeaders();
   // Send a DATA frame.
   scoped_refptr<StringIOBuffer> buf(new StringIOBuffer(body_data.substr(0, 5)));
   scoped_refptr<StringIOBuffer> buf2(
       new StringIOBuffer(body_data.substr(5, body_data.size() - 5)));
   delegate->SendvData({buf, buf2.get()}, {buf->size(), buf2->size()}, true);
   sequenced_data_->RunUntilPaused();  // OnHeadersReceived.
   // ReadData and it should return asynchronously because no data is buffered.
   EXPECT_EQ(ERR_IO_PENDING, delegate->ReadData());
   sequenced_data_->Resume();
   base::RunLoop().RunUntilIdle();
@@ skipping 723 matching lines @@
   AlternativeServiceVector alternative_service_vector =
       http_session_->http_server_properties()->GetAlternativeServices(server);
   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