Cancel loading when body stream reader is detached.

content/child/web_url_loader_impl.cc

 // Copyright 2014 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/child/web_url_loader_impl.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 305 matching lines @@
                           bool was_ignored_by_handler,
                           bool stale_copy_in_cache,
                           const std::string& security_info,
                           const base::TimeTicks& completion_time,
                           int64 total_transfer_size) override;
 
  private:
   friend class base::RefCounted<Context>;
   ~Context() override;
 
+  // Called when the body data stream is detached from the reader side.
+  void CancelBodyStreaming();
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURLRequestLocally() const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   ResourceDispatcher* resource_dispatcher_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   WebReferrerPolicy referrer_policy_;
@@ skipping 275 matching lines @@
   scoped_refptr<Context> protect(this);
 
   if (request_.useStreamOnResponse()) {
     SharedMemoryDataConsumerHandle::BackpressureMode mode =
         SharedMemoryDataConsumerHandle::kDoNotApplyBackpressure;
     if (info.headers &&
         info.headers->HasHeaderValue("Cache-Control", "no-store")) {
       mode = SharedMemoryDataConsumerHandle::kApplyBackpressure;
     }
 
-    auto reader = make_scoped_ptr(
-        new SharedMemoryDataConsumerHandle(mode, &body_stream_writer_));
+    auto read_handle = make_scoped_ptr(new SharedMemoryDataConsumerHandle(
+        mode, base::Bind(&Context::CancelBodyStreaming, this),
+        &body_stream_writer_));
 
-    // The client takes |reader|'s ownership.
-    client_->didReceiveResponse(loader_, response, reader.release());
+    // Here |body_stream_writer_| has an indirect reference to |this| and that
+    // creates a reference cycle, but it is not a problem because the cycle
+    // will break if one of the following happens:
+    //  1) The body data transfer is done (with or without an error).
+    //  2) |read_handle| (and its reader) is detached.
+
+    // The client takes |read_handle|'s ownership.
+    client_->didReceiveResponse(loader_, response, read_handle.release());
     // TODO(yhirano): Support ftp listening and multipart
     return;
   } else {
     client_->didReceiveResponse(loader_, response);
   }
 
   // We may have been cancelled after didReceiveResponse, which would leave us
   // without a client and therefore without much need to do further handling.
   if (!client_)
     return;
@@ skipping 111 matching lines @@
     }
   }
 }
 
 WebURLLoaderImpl::Context::~Context() {
   if (request_id_ >= 0) {
     resource_dispatcher_->RemovePendingRequest(request_id_);
   }
 }
 
+void WebURLLoaderImpl::Context::CancelBodyStreaming() {
+  scoped_refptr<Context> protect(this);
+
+  // Notify renderer clients that the request is canceled.
+  if (ftp_listing_delegate_) {
+    ftp_listing_delegate_->OnCompletedRequest();
+    ftp_listing_delegate_.reset(NULL);
+  } else if (multipart_delegate_) {
+    multipart_delegate_->OnCompletedRequest();
+    multipart_delegate_.reset(NULL);
+  }
+
+  if (body_stream_writer_) {
+    body_stream_writer_->Fail();
+    body_stream_writer_.reset();
+  }
+  if (client_) {
+    // TODO(yhirano): Set |stale_copy_in_cache| appropriately if possible.
+    client_->didFail(
+        loader_, CreateWebURLError(request_.url(), false, net::ERR_ABORTED));
+  }
+
+  // Notify the browser process that the request is canceled.
+  Cancel();
+}
+
 bool WebURLLoaderImpl::Context::CanHandleDataURLRequestLocally() const {
   GURL url = request_.url();
   if (!url.SchemeIs(url::kDataScheme))
     return false;
 
   // The fast paths for data URL, Start() and HandleDataURL(), don't support
   // the downloadToFile option.
   if (request_.downloadToFile())
     return false;
 
@@ skipping 233 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 bool WebURLLoaderImpl::attachThreadedDataReceiver(
     blink::WebThreadedDataReceiver* threaded_data_receiver) {
   return context_->AttachThreadedDataReceiver(threaded_data_receiver);
 }
 
 }  // namespace content