Remove WebURLLoader* argument from WebURLLoaderClient methods

third_party/WebKit/Source/core/fetch/ResourceLoader.cpp

 /*
  * Copyright (C) 2006, 2007, 2010, 2011 Apple Inc. All rights reserved.
  *           (C) 2007 Graham Dennis (graham.dennis@gmail.com)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 98 matching lines @@
   CHECK_EQ(m_resource->options().synchronousPolicy, RequestAsynchronously);
   m_loader.reset();
   start(request, loadingTaskRunner, defersLoading);
 }
 
 void ResourceLoader::setDefersLoading(bool defers) {
   DCHECK(m_loader);
   m_loader->setDefersLoading(defers);
 }
 
-void ResourceLoader::didDownloadData(WebURLLoader*,
-                                     int length,
-                                     int encodedDataLength) {
+void ResourceLoader::didDownloadData(int length, int encodedDataLength) {
   m_fetcher->didDownloadData(m_resource.get(), length, encodedDataLength);
   m_resource->didDownloadData(length);
 }
 
 void ResourceLoader::didChangePriority(ResourceLoadPriority loadPriority,
                                        int intraPriorityValue) {
   if (m_loader) {
     m_loader->didChangePriority(
         static_cast<WebURLRequest::Priority>(loadPriority), intraPriorityValue);
   }
 }
 
 void ResourceLoader::cancel() {
   didFail(
       ResourceError::cancelledError(m_resource->lastResourceRequest().url()));
 }
 
 void ResourceLoader::cancelForRedirectAccessCheckError(const KURL& newURL) {
   m_resource->willNotFollowRedirect();
 
   if (m_loader)
     didFail(ResourceError::cancelledDueToAccessCheckError(newURL));
 }
 
 bool ResourceLoader::willFollowRedirect(
-    WebURLLoader*,
     WebURLRequest& passedNewRequest,
     const WebURLResponse& passedRedirectResponse) {
   DCHECK(!passedNewRequest.isNull());
   DCHECK(!passedRedirectResponse.isNull());
 
   if (m_isCacheAwareLoadingActivated) {
     // Fail as cache miss if cached response is a redirect.
     didFail(
         ResourceError::cacheMissError(m_resource->lastResourceRequest().url()));
     return false;
@@ skipping 25 matching lines @@
   }
 
   if (!m_resource->willFollowRedirect(newRequest, redirectResponse)) {
     cancelForRedirectAccessCheckError(newRequest.url());
     return false;
   }
 
   return true;
 }
 
-void ResourceLoader::didReceiveCachedMetadata(WebURLLoader*,
-                                              const char* data,
-                                              int length) {
+void ResourceLoader::didReceiveCachedMetadata(const char* data, int length) {
   m_resource->setSerializedCachedMetadata(data, length);
 }
 
-void ResourceLoader::didSendData(WebURLLoader*,
-                                 unsigned long long bytesSent,
+void ResourceLoader::didSendData(unsigned long long bytesSent,
                                  unsigned long long totalBytesToBeSent) {
   m_resource->didSendData(bytesSent, totalBytesToBeSent);
 }
 
 void ResourceLoader::didReceiveResponse(
-    WebURLLoader*,
     const WebURLResponse& response,
     std::unique_ptr<WebDataConsumerHandle> handle) {
   DCHECK(!response.isNull());
   m_fetcher->didReceiveResponse(m_resource.get(), response.toResourceResponse(),
                                 std::move(handle));
 }
 
-void ResourceLoader::didReceiveResponse(WebURLLoader* loader,
-                                        const WebURLResponse& response) {
-  didReceiveResponse(loader, response, nullptr);
+void ResourceLoader::didReceiveResponse(const WebURLResponse& response) {
+  didReceiveResponse(response, nullptr);
 }
 
-void ResourceLoader::didReceiveData(WebURLLoader*,
-                                    const char* data,
+void ResourceLoader::didReceiveData(const char* data,
                                     int length,
                                     int encodedDataLength) {
   CHECK_GE(length, 0);
   m_fetcher->didReceiveData(m_resource.get(), data, length, encodedDataLength);
   m_resource->addToDecodedBodyLength(length);
   m_resource->appendData(data, length);
 }
 
 void ResourceLoader::didFinishLoadingFirstPartInMultipart() {
   m_fetcher->didFinishLoading(m_resource.get(), 0,
                               ResourceFetcher::DidFinishFirstPartInMultipart);
 }
 
-void ResourceLoader::didFinishLoading(WebURLLoader*,
-                                      double finishTime,
+void ResourceLoader::didFinishLoading(double finishTime,
                                       int64_t encodedDataLength,
                                       int64_t encodedBodyLength) {
   m_resource->setEncodedDataLength(encodedDataLength);
   m_resource->addToEncodedBodyLength(encodedBodyLength);
   m_loader.reset();
   m_fetcher->didFinishLoading(m_resource.get(), finishTime,
                               ResourceFetcher::DidFinishLoading);
 }
 
-void ResourceLoader::didFail(WebURLLoader*,
-                             const WebURLError& error,
+void ResourceLoader::didFail(const WebURLError& error,
                              int64_t encodedDataLength,
                              int64_t encodedBodyLength) {
   m_resource->setEncodedDataLength(encodedDataLength);
   m_resource->addToEncodedBodyLength(encodedBodyLength);
   didFail(error);
 }
 
 void ResourceLoader::didFail(const ResourceError& error) {
   if (m_isCacheAwareLoadingActivated && error.isCacheMiss() &&
       m_fetcher->context().shouldLoadNewResource(m_resource->getType())) {
@@ skipping 22 matching lines @@
   int64_t encodedDataLength = WebURLLoaderClient::kUnknownEncodedDataLength;
   int64_t encodedBodyLength = 0;
   m_loader->loadSynchronously(requestIn, responseOut, errorOut, dataOut,
                               encodedDataLength, encodedBodyLength);
 
   // A message dispatched while synchronously fetching the resource
   // can bring about the cancellation of this load.
   if (!m_loader)
     return;
   if (errorOut.reason) {
-    didFail(0, errorOut, encodedDataLength, encodedBodyLength);
+    didFail(errorOut, encodedDataLength, encodedBodyLength);
     return;
   }
-  didReceiveResponse(0, responseOut);
+  didReceiveResponse(responseOut);
   if (!m_loader)
     return;
   DCHECK_GE(responseOut.toResourceResponse().encodedBodyLength(), 0);
 
   // Follow the async case convention of not calling didReceiveData or
   // appending data to m_resource if the response body is empty. Copying the
   // empty buffer is a noop in most cases, but is destructive in the case of
   // a 304, where it will overwrite the cached data we should be reusing.
   if (dataOut.size()) {
     m_fetcher->didReceiveData(m_resource.get(), dataOut.data(), dataOut.size(),
                               encodedDataLength);
     m_resource->setResourceBuffer(dataOut);
   }
-  didFinishLoading(0, monotonicallyIncreasingTime(), encodedDataLength,
+  didFinishLoading(monotonicallyIncreasingTime(), encodedDataLength,
                    encodedBodyLength);
 }
 
 void ResourceLoader::activateCacheAwareLoadingIfNeeded(
     const ResourceRequest& request) {
   DCHECK(!m_isCacheAwareLoadingActivated);
 
   if (m_resource->options().cacheAwareLoadingEnabled !=
       IsCacheAwareLoadingEnabled)
     return;
 
   // Synchronous requests are not supported.
   if (m_resource->options().synchronousPolicy == RequestSynchronously)
     return;
 
   // Don't activate on Resource revalidation.
   if (m_resource->isCacheValidator())
     return;
 
   // Don't activate if cache policy is explicitly set.
   if (request.getCachePolicy() != WebCachePolicy::UseProtocolCachePolicy)
     return;
 
   m_isCacheAwareLoadingActivated = true;
 }
 
 }  // namespace blink