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

net/quic/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/bidirectional_stream_quic_impl.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 57 matching lines @@
                    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),
         error_(OK),
         on_data_read_count_(0),
         on_data_sent_count_(0),
         not_expect_callback_(false),
-        disable_auto_flush_(false) {
+        delay_headers_until_next_send_data_(false) {
     loop_.reset(new base::RunLoop);
   }
 
   ~TestDelegateBase() override {}
 
   void OnStreamReady() override {
     CHECK(!not_expect_callback_);
     loop_->Quit();
   }
 
@@ skipping 34 matching lines @@
     CHECK_NE(OK, error);
 
     error_ = error;
     loop_->Quit();
   }
 
   void Start(const BidirectionalStreamRequestInfo* request_info,
              const BoundNetLog& net_log,
              const base::WeakPtr<QuicChromiumClientSession> session) {
     stream_job_.reset(new BidirectionalStreamQuicImpl(session));
-    stream_job_->Start(request_info, net_log, disable_auto_flush_, this,
-                       nullptr);
+    stream_job_->Start(request_info, net_log,
+                       delay_headers_until_next_send_data_, this, nullptr);
   }
 
   void SendData(const scoped_refptr<IOBuffer>& data,
                 int length,
                 bool end_of_stream) {
     not_expect_callback_ = true;
     stream_job_->SendData(data, length, end_of_stream);
     not_expect_callback_ = false;
   }
 
@@ skipping 27 matching lines @@
   void CancelStream() { stream_job_->Cancel(); }
 
   NextProto GetProtocol() const { return stream_job_->GetProtocol(); }
 
   int64_t GetTotalReceivedBytes() const {
     return stream_job_->GetTotalReceivedBytes();
   }
 
   int64_t GetTotalSentBytes() const { return stream_job_->GetTotalSentBytes(); }
 
-  void DisableAutoFlush() { disable_auto_flush_ = true; }
+  void DelayHeadersUntilNextSendData() {
+    delay_headers_until_next_send_data_ = true;
+  }
 
   // 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_; }
 
  protected:
@@ skipping 12 matching lines @@
   std::unique_ptr<base::RunLoop> loop_;
   SpdyHeaderBlock response_headers_;
   SpdyHeaderBlock trailers_;
   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_;
   CompletionCallback callback_;
-  bool disable_auto_flush_;
+  bool delay_headers_until_next_send_data_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
 };
 
 // A delegate that deletes the stream in a particular callback.
 class DeleteStreamDelegate : public TestDelegateBase {
  public:
   // Specifies in which callback the stream can be deleted.
   enum Phase {
     ON_HEADERS_RECEIVED,
@@ skipping 472 matching lines @@
 
   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->DisableAutoFlush();
+  delegate->DelayHeadersUntilNextSendData();
   delegate->Start(&request, net_log().bound(), session()->GetWeakPtr());
   delegate->WaitUntilNextCallback();  // OnStreamReady
 
   // Send a Data packet.
   scoped_refptr<StringIOBuffer> buf1(new StringIOBuffer(kBody1));
   scoped_refptr<StringIOBuffer> buf2(new StringIOBuffer(kBody2));
 
   std::vector<int> lengths = {buf1->size(), buf2->size()};
   delegate->SendvData({buf1, buf2}, lengths, !kFin);
   delegate->WaitUntilNextCallback();  // OnDataSent
@@ skipping 623 matching lines @@
 
   base::MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(1, delegate->on_data_read_count());
   EXPECT_EQ(0, delegate->on_data_sent_count());
 }
 
 }  // namespace test
 
 }  // namespace net