Fix network service hanging with empty bodies.

content/network/url_loader_impl.cc

 // Copyright 2017 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 "content/network/url_loader_impl.h"
 
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "content/common/net_adapters.h"
@@ skipping 253 matching lines @@
   if (metadata) {
     const uint8_t* data = reinterpret_cast<const uint8_t*>(metadata->data());
 
     url_loader_client_->OnReceiveCachedMetadata(
         std::vector<uint8_t>(data, data + metadata->size()));
   }
 
   mojo::DataPipe data_pipe(kDefaultAllocationSize);
 
   response_body_stream_ = std::move(data_pipe.producer_handle);
-  response_body_consumer_handle_ = std::move(data_pipe.consumer_handle);
+  url_loader_client_->OnStartLoadingResponseBody(
+      std::move(data_pipe.consumer_handle));
   peer_closed_handle_watcher_.Watch(
       response_body_stream_.get(), MOJO_HANDLE_SIGNAL_PEER_CLOSED,
       base::Bind(&URLLoaderImpl::OnResponseBodyStreamClosed,
                  base::Unretained(this)));
   peer_closed_handle_watcher_.ArmOrNotify();
 
   writable_handle_watcher_.Watch(
       response_body_stream_.get(), MOJO_HANDLE_SIGNAL_WRITABLE,
       base::Bind(&URLLoaderImpl::OnResponseBodyStreamReady,
                  base::Unretained(this)));
@@ skipping 22 matching lines @@
     return;
   }
 
   CHECK_GT(static_cast<uint32_t>(std::numeric_limits<int>::max()), num_bytes);
   scoped_refptr<net::IOBuffer> buf(new NetToMojoIOBuffer(pending_write_.get()));
   int bytes_read;
   url_request_->Read(buf.get(), static_cast<int>(num_bytes), &bytes_read);
   if (url_request_->status().is_io_pending()) {
     // Wait for OnReadCompleted.
   } else if (url_request_->status().is_success() && bytes_read > 0) {
-    SendDataPipeIfNecessary();
     DidRead(static_cast<uint32_t>(bytes_read), true);
   } else {
     NotifyCompleted(net::OK);
     writable_handle_watcher_.Cancel();
     pending_write_->Complete(0);
     pending_write_ = nullptr;  // This closes the data pipe.
     DeleteIfNeeded();
     return;
   }
 }
@@ skipping 15 matching lines @@
                                     int bytes_read) {
   DCHECK(url_request == url_request_.get());
 
   if (!url_request->status().is_success()) {
     writable_handle_watcher_.Cancel();
     pending_write_ = nullptr;  // This closes the data pipe.
     DeleteIfNeeded();
     return;
   }
 
-  SendDataPipeIfNecessary();
-
   DidRead(static_cast<uint32_t>(bytes_read), false);
 }
 
 void URLLoaderImpl::NotifyCompleted(int error_code) {
   ResourceRequestCompletionStatus request_complete_data;
   request_complete_data.error_code = error_code;
   request_complete_data.exists_in_cache =
       url_request_->response_info().was_cached;
   request_complete_data.completion_time = base::TimeTicks::Now();
   request_complete_data.encoded_data_length =
       url_request_->GetTotalReceivedBytes();
   request_complete_data.encoded_body_length = url_request_->GetRawBodyBytes();
 
   url_loader_client_->OnComplete(request_complete_data);
   DeleteIfNeeded();
 }
 
-void URLLoaderImpl::SendDataPipeIfNecessary() {
-  if (response_body_consumer_handle_.is_valid()) {
-    // Send the data pipe on the first OnReadCompleted call.
-    url_loader_client_->OnStartLoadingResponseBody(
-        std::move(response_body_consumer_handle_));
-  }
-}
-
 void URLLoaderImpl::OnConnectionError() {
   connected_ = false;
   DeleteIfNeeded();
 }
 
 void URLLoaderImpl::OnResponseBodyStreamClosed(MojoResult result) {
   url_request_.reset();
   response_body_stream_.reset();
   pending_write_ = nullptr;
   DeleteIfNeeded();
 }
 
 void URLLoaderImpl::OnResponseBodyStreamReady(MojoResult result) {
   // TODO: Handle a bad |result| value.
   DCHECK_EQ(result, MOJO_RESULT_OK);
   ReadMore();
 }
 
 void URLLoaderImpl::DeleteIfNeeded() {
   bool has_data_pipe = pending_write_.get() || response_body_stream_.is_valid();
   if (!connected_ && !has_data_pipe)
     delete this;
 }
 
 }  // namespace content