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

components/cronet/android/cronet_bidirectional_stream_adapter.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 "cronet_bidirectional_stream_adapter.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 53 matching lines @@
   // Reset global references.
   jwrite_buffer_list.Reset();
   jwrite_buffer_pos_list.Reset();
   jwrite_buffer_limit_list.Reset();
 }
 
 static jlong CreateBidirectionalStream(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& jbidi_stream,
     jlong jurl_request_context_adapter,
-    jboolean jdisable_auto_flush) {
+    jboolean jsend_request_headers_automatically) {
   CronetURLRequestContextAdapter* context_adapter =
       reinterpret_cast<CronetURLRequestContextAdapter*>(
           jurl_request_context_adapter);
   DCHECK(context_adapter);
 
   CronetBidirectionalStreamAdapter* adapter =
       new CronetBidirectionalStreamAdapter(context_adapter, env, jbidi_stream,
-                                           jdisable_auto_flush);
+                                           jsend_request_headers_automatically);
 
   return reinterpret_cast<jlong>(adapter);
 }
 
 // static
 bool CronetBidirectionalStreamAdapter::RegisterJni(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 CronetBidirectionalStreamAdapter::CronetBidirectionalStreamAdapter(
     CronetURLRequestContextAdapter* context,
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& jbidi_stream,
-    bool disable_auto_flush)
+    bool send_request_headers_automatically)
     : context_(context),
       owner_(env, jbidi_stream),
-      disable_auto_flush_(disable_auto_flush),
+      send_request_headers_automatically_(send_request_headers_automatically),
       stream_failed_(false) {}
 
 CronetBidirectionalStreamAdapter::~CronetBidirectionalStreamAdapter() {
   DCHECK(context_->IsOnNetworkThread());
 }
 
+void CronetBidirectionalStreamAdapter::SendRequestHeaders(
+    JNIEnv* env,
+    const base::android::JavaParamRef<jobject>& jcaller) {
+  context_->PostTaskToNetworkThread(
+      FROM_HERE,
+      base::Bind(
+          &CronetBidirectionalStreamAdapter::SendRequestHeadersOnNetworkThread,
+          base::Unretained(this)));
+}
+
 jint CronetBidirectionalStreamAdapter::Start(
     JNIEnv* env,
     const base::android::JavaParamRef<jobject>& jcaller,
     const base::android::JavaParamRef<jstring>& jurl,
     jint jpriority,
     const base::android::JavaParamRef<jstring>& jmethod,
     const base::android::JavaParamRef<jobjectArray>& jheaders,
     jboolean jend_of_stream) {
   // Prepare request info here to be able to return the error.
   std::unique_ptr<net::BidirectionalStreamRequestInfo> request_info(
@@ skipping 105 matching lines @@
   // posting task to executor throws an exception), but is posted, so |this|
   // is valid until calling task is complete. Destroy() is always called from
   // within a synchronized java block that guarantees no future posts to the
   // network thread with the adapter pointer.
   context_->PostTaskToNetworkThread(
       FROM_HERE,
       base::Bind(&CronetBidirectionalStreamAdapter::DestroyOnNetworkThread,
                  base::Unretained(this), jsend_on_canceled));
 }
 
-void CronetBidirectionalStreamAdapter::OnStreamReady() {
+void CronetBidirectionalStreamAdapter::OnStreamReady(
+    bool request_headers_sent) {
   DCHECK(context_->IsOnNetworkThread());
   JNIEnv* env = base::android::AttachCurrentThread();
-  cronet::Java_CronetBidirectionalStream_onStreamReady(env, owner_.obj());
+  cronet::Java_CronetBidirectionalStream_onStreamReady(
+      env, owner_.obj(), request_headers_sent ? JNI_TRUE : JNI_FALSE);
 }
 
 void CronetBidirectionalStreamAdapter::OnHeadersReceived(
     const net::SpdyHeaderBlock& response_headers) {
   DCHECK(context_->IsOnNetworkThread());
   JNIEnv* env = base::android::AttachCurrentThread();
   // Get http status code from response headers.
   jint http_status_code = 0;
   const auto http_status_header = response_headers.find(":status");
   if (http_status_header != response_headers.end())
@@ skipping 69 matching lines @@
   DCHECK(context_->IsOnNetworkThread());
   DCHECK(!bidi_stream_);
   request_info->extra_headers.SetHeaderIfMissing(
       net::HttpRequestHeaders::kUserAgent, context_->GetURLRequestContext()
                                                ->http_user_agent_settings()
                                                ->GetUserAgent());
   bidi_stream_.reset(new net::BidirectionalStream(
       std::move(request_info), context_->GetURLRequestContext()
                                    ->http_transaction_factory()
                                    ->GetSession(),
-      disable_auto_flush_, this));
+      send_request_headers_automatically_, this));
+}
+
+void CronetBidirectionalStreamAdapter::SendRequestHeadersOnNetworkThread() {
+  DCHECK(context_->IsOnNetworkThread());
+  DCHECK(!send_request_headers_automatically_);
+
+  if (stream_failed_) {
+    // If stream failed between the time when SendRequestHeaders is invoked and
+    // SendRequestHeadersOnNetworkThread is executed, do not call into
+    // |bidi_stream_| since the underlying stream might have been destroyed.
+    // Do not invoke Java callback either, since onError is posted when
+    // |stream_failed_| is set to true.
+    return;
+  }
+  bidi_stream_->SendRequestHeaders();
 }
 
 void CronetBidirectionalStreamAdapter::ReadDataOnNetworkThread(
     scoped_refptr<IOBufferWithByteBuffer> read_buffer,
     int buffer_size) {
   DCHECK(context_->IsOnNetworkThread());
   DCHECK(read_buffer);
   DCHECK(!read_buffer_);
 
   read_buffer_ = read_buffer;
@@ skipping 56 matching lines @@
 
   std::vector<std::string> headers;
   for (const auto& header : header_block) {
     headers.push_back(header.first.as_string());
     headers.push_back(header.second.as_string());
   }
   return base::android::ToJavaArrayOfStrings(env, headers);
 }
 
 }  // namespace cronet