Remove WebURLLoader* argument from WebURLLoaderClient methods

content/child/web_url_loader_impl_unittest.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 <string.h>
 
 #include <utility>
@@ skipping 123 matching lines @@
         delete_on_fail_(false),
         did_receive_redirect_(false),
         did_receive_response_(false),
         check_redirect_request_priority_(false),
         did_finish_(false) {}
 
   ~TestWebURLLoaderClient() override {}
 
   // blink::WebURLLoaderClient implementation:
   bool willFollowRedirect(
-      blink::WebURLLoader* loader,
       blink::WebURLRequest& newRequest,
       const blink::WebURLResponse& redirectResponse) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
 
     if (check_redirect_request_priority_)
       EXPECT_EQ(redirect_request_priority, newRequest.getPriority());
 
     // No test currently simulates mutiple redirects.
     EXPECT_FALSE(did_receive_redirect_);
     did_receive_redirect_ = true;
 
     if (delete_on_receive_redirect_)
       loader_.reset();
 
     return true;
   }
 
-  void didSendData(blink::WebURLLoader* loader,
-                   unsigned long long bytesSent,
+  void didSendData(unsigned long long bytesSent,
                    unsigned long long totalBytesToBeSent) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
   }
 
   void didReceiveResponse(
-      blink::WebURLLoader* loader,
       const blink::WebURLResponse& response) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
     EXPECT_FALSE(did_receive_response_);
 
     did_receive_response_ = true;
     response_ = response;
     if (delete_on_receive_response_)
       loader_.reset();
   }
 
-  void didDownloadData(blink::WebURLLoader* loader,
-                       int dataLength,
-                       int encodedDataLength) override {
+  void didDownloadData(int dataLength, int encodedDataLength) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
   }
 
-  void didReceiveData(blink::WebURLLoader* loader,
-                      const char* data,
+  void didReceiveData(const char* data,
                       int dataLength,
                       int encodedDataLength) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
     // The response should have started, but must not have finished, or failed.
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     EXPECT_EQ(net::OK, error_.reason);
     EXPECT_EQ("", error_.domain.utf8());
 
     received_data_.append(data, dataLength);
 
     if (delete_on_receive_data_)
       loader_.reset();
   }
 
-  void didReceiveCachedMetadata(blink::WebURLLoader* loader,
-                                const char* data,
-                                int dataLength) override {
-    EXPECT_EQ(loader_.get(), loader);
-  }
-
-  void didFinishLoading(blink::WebURLLoader* loader,
-                        double finishTime,
+  void didFinishLoading(double finishTime,
                         int64_t totalEncodedDataLength,
                         int64_t totalEncodedBodyLength) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
     EXPECT_TRUE(did_receive_response_);
     EXPECT_FALSE(did_finish_);
     did_finish_ = true;
 
     if (delete_on_finish_)
       loader_.reset();
   }
 
-  void didFail(blink::WebURLLoader* loader,
-               const blink::WebURLError& error,
+  void didFail(const blink::WebURLError& error,
                int64_t totalEncodedDataLength,
                int64_t totalEncodedBodyLength) override {
     EXPECT_TRUE(loader_);
-    EXPECT_EQ(loader_.get(), loader);
     EXPECT_FALSE(did_finish_);
     error_ = error;
 
     if (delete_on_fail_)
       loader_.reset();
   }
 
   WebURLLoaderImpl* loader() { return loader_.get(); }
   void DeleteLoader() {
     loader_.reset();
@@ skipping 464 matching lines @@
   int64_t encoded_body_length = 0;
   client()->loader()->loadSynchronously(
       request, response, error, data, encoded_data_length, encoded_body_length);
 
   EXPECT_EQ(kEncodedBodyLength, encoded_body_length);
   EXPECT_EQ(kEncodedDataLength, encoded_data_length);
 }
 
 }  // namespace
 }  // namespace content