AssociatedURLLoader shouldn't derive from WebURLLoader

media/blink/resource_multibuffer_data_provider_unittest.cc

 // Copyright 2015 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 "media/blink/resource_multibuffer_data_provider.h"
 
 #include <stdint.h>
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "media/base/media_log.h"
 #include "media/base/seekable_buffer.h"
-#include "media/blink/mock_weburlloader.h"
+#include "media/blink/mock_webassociatedurlloader.h"
 #include "media/blink/url_index.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_util.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
@@ skipping 66 matching lines @@
                    base::Unretained(this)));
 
     first_position_ = first_position;
 
     std::unique_ptr<ResourceMultiBufferDataProvider> loader(
         new ResourceMultiBufferDataProvider(url_data_.get(), first_position_));
     loader_ = loader.get();
     url_data_->multibuffer()->AddProvider(std::move(loader));
 
     // |test_loader_| will be used when Start() is called.
-    url_loader_ = new NiceMock<MockWebURLLoader>();
-    loader_->test_loader_ = std::unique_ptr<blink::WebURLLoader>(url_loader_);
+    url_loader_ = new NiceMock<MockWebAssociatedURLLoader>();
+    loader_->test_loader_ =
+        std::unique_ptr<blink::WebAssociatedURLLoader>(url_loader_);
   }
 
   void Start() {
     InSequence s;
     EXPECT_CALL(
         *url_loader_,
         loadAsynchronously(Truly(CorrectAcceptEncodingAndEtag), loader_));
 
     loader_->Start();
   }
 
   void FullResponse(int64_t instance_size, bool ok = true) {
     WebURLResponse response(gurl_);
     response.setHTTPHeaderField(
         WebString::fromUTF8("Content-Length"),
         WebString::fromUTF8(base::StringPrintf("%" PRId64, instance_size)));
     response.setExpectedContentLength(instance_size);
     response.setHTTPStatusCode(kHttpOK);
-    loader_->didReceiveResponse(url_loader_, response);
+    loader_->didReceiveResponse(response);
 
     if (ok) {
       EXPECT_EQ(instance_size, url_data_->length());
     }
 
     EXPECT_FALSE(url_data_->range_supported());
   }
 
   void PartialResponse(int64_t first_position,
                        int64_t last_position,
@@ skipping 24 matching lines @@
     }
     response.setExpectedContentLength(content_length);
 
     // A server isn't required to return Accept-Ranges even though it might.
     if (accept_ranges) {
       response.setHTTPHeaderField(WebString::fromUTF8("Accept-Ranges"),
                                   WebString::fromUTF8("bytes"));
     }
 
     response.setHTTPStatusCode(kHttpPartialContent);
-    loader_->didReceiveResponse(url_loader_, response);
+    loader_->didReceiveResponse(response);
 
     EXPECT_EQ(instance_size, url_data_->length());
 
     // A valid partial response should always result in this being true.
     EXPECT_TRUE(url_data_->range_supported());
   }
 
   void Redirect(const char* url) {
     GURL redirectUrl(url);
     blink::WebURLRequest newRequest(redirectUrl);
     blink::WebURLResponse redirectResponse(gurl_);
 
     EXPECT_CALL(*this, RedirectCallback(_))
         .WillOnce(
             Invoke(this, &ResourceMultiBufferDataProviderTest::SetUrlData));
 
-    loader_->willFollowRedirect(url_loader_, newRequest, redirectResponse);
+    loader_->willFollowRedirect(newRequest, redirectResponse);
 
     base::RunLoop().RunUntilIdle();
   }
 
   void StopWhenLoad() {
     InSequence s;
     EXPECT_CALL(*url_loader_, cancel());
     loader_ = nullptr;
     url_data_ = nullptr;
   }
 
   // Helper method to write to |loader_| from |data_|.
   void WriteLoader(int position, int size) {
-    loader_->didReceiveData(url_loader_,
-                            reinterpret_cast<char*>(data_ + position), size,
-                            size, size);
+    loader_->didReceiveData(reinterpret_cast<char*>(data_ + position), size);
   }
 
   void WriteData(int size) {
     std::unique_ptr<char[]> data(new char[size]);
-    loader_->didReceiveData(url_loader_, data.get(), size, size, size);
+    loader_->didReceiveData(data.get(), size);
   }
 
   // Verifies that data in buffer[0...size] is equal to data_[pos...pos+size].
   void VerifyBuffer(uint8_t* buffer, int pos, int size) {
     EXPECT_EQ(0, memcmp(buffer, data_ + pos, size));
   }
 
   bool HasActiveLoader() { return loader_->active_loader_ != nullptr; }
   MOCK_METHOD1(RedirectCallback, void(const scoped_refptr<UrlData>&));
 
   void SetUrlData(const scoped_refptr<UrlData>& new_url_data) {
     url_data_ = new_url_data;
   }
 
  protected:
   GURL gurl_;
   int64_t first_position_;
 
   std::unique_ptr<UrlIndex> url_index_;
   scoped_refptr<UrlData> url_data_;
   scoped_refptr<UrlData> redirected_to_;
   // The loader is owned by the UrlData above.
   ResourceMultiBufferDataProvider* loader_;
-  NiceMock<MockWebURLLoader>* url_loader_;
+  NiceMock<MockWebAssociatedURLLoader>* url_loader_;
 
   blink::WebFrameClient client_;
   WebView* view_;
 
   base::MessageLoop message_loop_;
 
   uint8_t data_[kDataSize];
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ResourceMultiBufferDataProviderTest);
 };
 
 TEST_F(ResourceMultiBufferDataProviderTest, StartStop) {
   Initialize(kHttpUrl, 0);
   Start();
   StopWhenLoad();
 }
 
 // Tests that a bad HTTP response is recived, e.g. file not found.
 TEST_F(ResourceMultiBufferDataProviderTest, BadHttpResponse) {
   Initialize(kHttpUrl, 0);
   Start();
 
   EXPECT_CALL(*this, RedirectCallback(scoped_refptr<UrlData>(nullptr)));
 
   WebURLResponse response(gurl_);
   response.setHTTPStatusCode(404);
   response.setHTTPStatusText("Not Found\n");
-  loader_->didReceiveResponse(url_loader_, response);
+  loader_->didReceiveResponse(response);
 }
 
 // Tests that partial content is requested but not fulfilled.
 TEST_F(ResourceMultiBufferDataProviderTest, NotPartialResponse) {
   Initialize(kHttpUrl, 100);
   Start();
   FullResponse(1024, false);
 }
 
 // Tests that a 200 response is received.
@@ skipping 42 matching lines @@
   EXPECT_CALL(*this, RedirectCallback(scoped_refptr<UrlData>(nullptr)));
 
   WebURLResponse response(gurl_);
   response.setHTTPHeaderField(
       WebString::fromUTF8("Content-Range"),
       WebString::fromUTF8(base::StringPrintf("bytes "
                                              "%d-%d/%d",
                                              1, 10, 1024)));
   response.setExpectedContentLength(10);
   response.setHTTPStatusCode(kHttpPartialContent);
-  loader_->didReceiveResponse(url_loader_, response);
+  loader_->didReceiveResponse(response);
 }
 
 TEST_F(ResourceMultiBufferDataProviderTest, TestRedirects) {
   // Test redirect.
   Initialize(kHttpUrl, 0);
   Start();
   Redirect(kHttpRedirect);
   FullResponse(1024);
   StopWhenLoad();
 }
 
 }  // namespace media