Remove WebURLLoader* argument from WebURLLoaderClient methods

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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 630 matching lines @@
 }
 
 void WebURLLoaderImpl::Context::SetTaskRunner(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
   task_runner_ = task_runner;
 }
 
 void WebURLLoaderImpl::Context::OnUploadProgress(uint64_t position,
                                                  uint64_t size) {
   if (client_)
-    client_->didSendData(loader_, position, size);
+    client_->didSendData(position, size);
 }
 
 bool WebURLLoaderImpl::Context::OnReceivedRedirect(
     const net::RedirectInfo& redirect_info,
     const ResourceResponseInfo& info) {
   if (!client_)
     return false;
 
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedRedirect",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   WebURLResponse response;
   PopulateURLResponse(request_.url(), info, &response,
                       request_.reportRawHeaders());
 
   WebURLRequest new_request = PopulateURLRequestForRedirect(
       request_, redirect_info,
       info.was_fetched_via_service_worker
           ? blink::WebURLRequest::SkipServiceWorker::None
           : blink::WebURLRequest::SkipServiceWorker::All);
 
-  bool follow = client_->willFollowRedirect(loader_, new_request, response);
+  bool follow = client_->willFollowRedirect(new_request, response);
   if (!follow) {
     request_ = WebURLRequest();
 
     return false;
   }
 
   DCHECK(WebURL(redirect_info.new_url) == new_request.url());
 
   request_ = new_request;
 
@@ skipping 79 matching lines @@
 
     auto read_handle = base::MakeUnique<SharedMemoryDataConsumerHandle>(
         mode, base::Bind(&Context::CancelBodyStreaming, this),
         &body_stream_writer_);
 
     // 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.
-    client_->didReceiveResponse(loader_, response, std::move(read_handle));
+    client_->didReceiveResponse(response, std::move(read_handle));
     // TODO(yhirano): Support ftp listening and multipart
     return;
   } else {
-    client_->didReceiveResponse(loader_, response);
+    client_->didReceiveResponse(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;
 
   DCHECK(!ftp_listing_delegate_.get());
   if (info.mime_type == "text/vnd.chromium.ftp-dir" && !show_raw_listing) {
     ftp_listing_delegate_.reset(
         new FtpDirectoryListingResponseDelegate(client_, loader_, response));
   }
 }
 
 void WebURLLoaderImpl::Context::OnDownloadedData(int len,
                                                  int encoded_data_length) {
   if (client_)
-    client_->didDownloadData(loader_, len, encoded_data_length);
+    client_->didDownloadData(len, encoded_data_length);
 }
 
 void WebURLLoaderImpl::Context::OnReceivedData(
     std::unique_ptr<ReceivedData> data) {
   const char* payload = data->payload();
   int data_length = data->length();
   int encoded_data_length = data->encoded_data_length();
   if (!client_)
     return;
 
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedData",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
 
   if (ftp_listing_delegate_) {
     // The FTP listing delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.
     ftp_listing_delegate_->OnReceivedData(payload, data_length);
   } else {
     // We dispatch the data even when |useStreamOnResponse()| is set, in order
     // to make Devtools work.
-    client_->didReceiveData(loader_, payload, data_length, encoded_data_length);
+    client_->didReceiveData(payload, data_length, encoded_data_length);
 
     if (request_.useStreamOnResponse()) {
       // We don't support ftp_listening_delegate_ for now.
       // TODO(yhirano): Support ftp listening.
       body_stream_writer_->AddData(std::move(data));
     }
   }
 }
 
 void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
     const char* data, int len) {
   if (!client_)
     return;
   TRACE_EVENT_WITH_FLOW0(
       "loading", "WebURLLoaderImpl::Context::OnReceivedCachedMetadata",
       this, TRACE_EVENT_FLAG_FLOW_IN | TRACE_EVENT_FLAG_FLOW_OUT);
-  client_->didReceiveCachedMetadata(loader_, data, len);
+  client_->didReceiveCachedMetadata(data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     int error_code,
     bool was_ignored_by_handler,
     bool stale_copy_in_cache,
     const base::TimeTicks& completion_time,
     int64_t total_transfer_size,
     int64_t encoded_body_size) {
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   }
 
   if (body_stream_writer_ && error_code != net::OK)
     body_stream_writer_->Fail();
   body_stream_writer_.reset();
 
   if (client_) {
     TRACE_EVENT_WITH_FLOW0(
         "loading", "WebURLLoaderImpl::Context::OnCompletedRequest",
         this, TRACE_EVENT_FLAG_FLOW_IN);
 
     if (error_code != net::OK) {
-      client_->didFail(loader_,
-                       CreateWebURLError(request_.url(), stale_copy_in_cache,
+      client_->didFail(CreateWebURLError(request_.url(), stale_copy_in_cache,
                                          error_code, was_ignored_by_handler),
                        total_transfer_size, encoded_body_size);
     } else {
-      client_->didFinishLoading(loader_,
-                                (completion_time - TimeTicks()).InSecondsF(),
+      client_->didFinishLoading((completion_time - TimeTicks()).InSecondsF(),
                                 total_transfer_size, encoded_body_size);
     }
   }
 }
 
 WebURLLoaderImpl::Context::~Context() {
   // We must be already cancelled at this point.
   DCHECK_LT(request_id_, 0);
 }
 
 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);
   }
 
   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),
+    client_->didFail(CreateWebURLError(request_.url(), false, net::ERR_ABORTED),
                      WebURLLoaderClient::kUnknownEncodedDataLength, 0);
   }
 
   // Notify the browser process that the request is canceled.
   Cancel();
 }
 
 bool WebURLLoaderImpl::Context::CanHandleDataURLRequestLocally() const {
   GURL url = request_.url();
   if (!url.SchemeIs(url::kDataScheme))
@@ skipping 350 matching lines @@
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 void WebURLLoaderImpl::setLoadingTaskRunner(
     base::SingleThreadTaskRunner* loading_task_runner) {
   context_->SetTaskRunner(loading_task_runner);
 }
 
 }  // namespace content