AssociatedURLLoader shouldn't derive from WebURLLoader

media/blink/multibuffer_data_source_unittest.cc

 // Copyright 2013 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 <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "media/base/media_log.h"
 #include "media/base/mock_filters.h"
 #include "media/base/test_helpers.h"
 #include "media/blink/buffered_data_source_host_impl.h"
-#include "media/blink/mock_weburlloader.h"
+#include "media/blink/mock_webassociatedurlloader.h"
 #include "media/blink/multibuffer_data_source.h"
 #include "media/blink/multibuffer_reader.h"
 #include "media/blink/resource_multibuffer_data_provider.h"
 #include "media/blink/test_response_generator.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"
 #include "third_party/WebKit/public/web/WebView.h"
 
 using ::testing::_;
 using ::testing::Assign;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::InvokeWithoutArgs;
 using ::testing::InSequence;
 using ::testing::NiceMock;
 using ::testing::StrictMock;
 
+using blink::WebAssociatedURLLoader;
 using blink::WebLocalFrame;
 using blink::WebString;
-using blink::WebURLLoader;
 using blink::WebURLResponse;
 using blink::WebView;
 
 namespace media {
 
 class TestResourceMultiBuffer;
 class TestMultiBufferDataProvider;
 
 std::set<TestMultiBufferDataProvider*> test_data_providers;
 
 class TestMultiBufferDataProvider : public ResourceMultiBufferDataProvider {
  public:
   TestMultiBufferDataProvider(UrlData* url_data, MultiBuffer::BlockId pos)
       : ResourceMultiBufferDataProvider(url_data, pos), loading_(false) {
     CHECK(test_data_providers.insert(this).second);
   }
   ~TestMultiBufferDataProvider() override {
     CHECK_EQ(static_cast<size_t>(1), test_data_providers.erase(this));
   }
   void Start() override {
     // Create a mock active loader.
     // Keep track of active loading state via loadAsynchronously() and cancel().
-    NiceMock<MockWebURLLoader>* url_loader = new NiceMock<MockWebURLLoader>();
+    NiceMock<MockWebAssociatedURLLoader>* url_loader =
+        new NiceMock<MockWebAssociatedURLLoader>();
     ON_CALL(*url_loader, cancel())
         .WillByDefault(Invoke([this]() {
           // Check that we have not been destroyed first.
           if (test_data_providers.find(this) != test_data_providers.end()) {
             this->loading_ = false;
           }
         }));
     loading_ = true;
     active_loader_.reset(
-        new ActiveLoader(std::unique_ptr<WebURLLoader>(url_loader)));
+        new ActiveLoader(std::unique_ptr<WebAssociatedURLLoader>(url_loader)));
     if (!on_start_.is_null()) {
       on_start_.Run();
     }
   }
 
   bool loading() const { return loading_; }
   void RunOnStart(base::Closure cb) { on_start_ = cb; }
 
  private:
   bool loading_;
@@ skipping 210 matching lines @@
 
     ReceiveData(kDataSize);
   }
 
   // Stops any active loaders and shuts down the data source.
   //
   // This typically happens when the page is closed and for our purposes is
   // appropriate to do when tearing down a test.
   void Stop() {
     if (loading()) {
-      data_provider()->didFail(url_loader(),
-                               response_generator_->GenerateError());
+      data_provider()->didFail(response_generator_->GenerateError());
       base::RunLoop().RunUntilIdle();
     }
 
     data_source_->Stop();
     base::RunLoop().RunUntilIdle();
   }
 
   void Respond(const WebURLResponse& response) {
     EXPECT_TRUE(url_loader());
     if (!active_loader())
       return;
-    data_provider()->didReceiveResponse(url_loader(), response);
+    data_provider()->didReceiveResponse(response);
     base::RunLoop().RunUntilIdle();
   }
 
   void ReceiveDataLow(int size) {
     EXPECT_TRUE(url_loader());
     if (!url_loader())
       return;
     std::unique_ptr<char[]> data(new char[size]);
     memset(data.get(), 0xA5, size);  // Arbitrary non-zero value.
 
-    data_provider()->didReceiveData(url_loader(), data.get(), size, size, size);
+    data_provider()->didReceiveData(data.get(), size);
   }
 
   void ReceiveData(int size) {
     ReceiveDataLow(size);
     base::RunLoop().RunUntilIdle();
   }
 
   void FinishLoading() {
     EXPECT_TRUE(url_loader());
     if (!url_loader())
       return;
-    data_provider()->didFinishLoading(url_loader(), 0, -1);
+    data_provider()->didFinishLoading(0);
     base::RunLoop().RunUntilIdle();
   }
 
   void FailLoading() {
-    data_provider()->didFail(url_loader(),
-                             response_generator_->GenerateError());
+    data_provider()->didFail(response_generator_->GenerateError());
     base::RunLoop().RunUntilIdle();
   }
 
   void Restart() {
     EXPECT_TRUE(data_provider());
     EXPECT_FALSE(active_loader_allownull());
     if (!data_provider())
       return;
     data_provider()->Start();
   }
@@ skipping 83 matching lines @@
       return nullptr;
     return data_provider()->active_loader_.get();
   }
   ActiveLoader* active_loader_allownull() {
     TestMultiBufferDataProvider* data_provider =
         multibuffer()->GetProvider_allownull();
     if (!data_provider)
       return nullptr;
     return data_provider->active_loader_.get();
   }
-  WebURLLoader* url_loader() {
+  WebAssociatedURLLoader* url_loader() {
     EXPECT_TRUE(active_loader());
     if (!active_loader())
       return nullptr;
     return active_loader()->loader_.get();
   }
 
   bool loading() { return multibuffer()->loading(); }
 
   MultibufferDataSource::Preload preload() { return data_source_->preload_; }
   void set_preload(MultibufferDataSource::Preload preload) {
@@ skipping 206 matching lines @@
 
   // Read to advance our position.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   ReadAt(0);
 
   // Issue a pending read but trigger an error to force a retry.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
   ReadAt(kDataSize);
   base::RunLoop run_loop;
-  data_provider()->didFail(url_loader(), response_generator_->GenerateError());
+  data_provider()->didFail(response_generator_->GenerateError());
   data_provider()->RunOnStart(run_loop.QuitClosure());
   run_loop.Run();
   Respond(response_generator_->Generate206(kDataSize));
   ReceiveData(kDataSize);
   FinishLoading();
   EXPECT_FALSE(loading());
   Stop();
 }
 
 // Make sure that we prefetch across partial responses. (crbug.com/516589)
@@ skipping 686 matching lines @@
 
   // Read to advance our position.
   EXPECT_CALL(*this, ReadCallback(kDataSize));
   ReadAt(0);
 
   // Issue a pending read but trigger an error to force a retry.
   EXPECT_CALL(*this, ReadCallback(kDataSize - 10));
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 2));
   ReadAt(kDataSize + 10, kDataSize - 10);
   base::RunLoop run_loop;
-  data_provider()->didFail(url_loader(), response_generator_->GenerateError());
+  data_provider()->didFail(response_generator_->GenerateError());
   data_provider()->RunOnStart(run_loop.QuitClosure());
   run_loop.Run();
 
   // Server responds with a redirect.
   blink::WebURLRequest request((GURL(kHttpDifferentPathUrl)));
   blink::WebURLResponse response((GURL(kHttpUrl)));
   response.setHTTPStatusCode(307);
-  data_provider()->willFollowRedirect(url_loader(), request, response);
+  data_provider()->willFollowRedirect(request, response);
   Respond(response_generator_->Generate206(kDataSize));
   ReceiveData(kDataSize);
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize * 3));
   FinishLoading();
   EXPECT_FALSE(loading());
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, Http_NotStreamingAfterRedirect) {
   Initialize(kHttpUrl, true);
 
   // Server responds with a redirect.
   blink::WebURLRequest request((GURL(kHttpDifferentPathUrl)));
   blink::WebURLResponse response((GURL(kHttpUrl)));
   response.setHTTPStatusCode(307);
-  data_provider()->willFollowRedirect(url_loader(), request, response);
+  data_provider()->willFollowRedirect(request, response);
 
   EXPECT_CALL(host_, SetTotalBytes(response_generator_->content_length()));
   Respond(response_generator_->Generate206(0));
 
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
   ReceiveData(kDataSize);
 
   EXPECT_FALSE(data_source_->IsStreaming());
 
   FinishLoading();
   EXPECT_FALSE(loading());
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, Http_RangeNotSatisfiableAfterRedirect) {
   Initialize(kHttpUrl, true);
 
   // Server responds with a redirect.
   blink::WebURLRequest request((GURL(kHttpDifferentPathUrl)));
   blink::WebURLResponse response((GURL(kHttpUrl)));
   response.setHTTPStatusCode(307);
-  data_provider()->willFollowRedirect(url_loader(), request, response);
+  data_provider()->willFollowRedirect(request, response);
 
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
   Respond(response_generator_->GenerateResponse(416));
   Stop();
 }
 
 TEST_F(MultibufferDataSourceTest, LengthKnownAtEOF) {
   Initialize(kHttpUrl, true);
   // Server responds without content-length.
   WebURLResponse response = response_generator_->Generate200();
@@ skipping 80 matching lines @@
   const std::string etag("\"arglebargle glop-glyf?\"");
   response.setHTTPHeaderField(WebString::fromUTF8("Etag"),
                               WebString::fromUTF8(etag));
   Respond(response);
   EXPECT_CALL(host_, AddBufferedByteRange(0, kDataSize));
   ReceiveData(kDataSize);
 
   EXPECT_EQ(url_data()->etag(), etag);
 }
 }  // namespace media