WebTaskRunnerImpl to take a TaskQueue

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>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
+#include "base/time/default_tick_clock.h"
 #include "base/time/time.h"
+#include "components/scheduler/child/scheduler_tqm_delegate_impl.h"
 #include "components/scheduler/child/web_task_runner_impl.h"
+#include "components/scheduler/child/worker_scheduler.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
 #include "content/child/resource_dispatcher.h"
 #include "content/public/child/fixed_received_data.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/resource_response_info.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
@@ skipping 69 matching lines @@
  private:
   scoped_ptr<RequestPeer> peer_;
   bool canceled_;
   GURL url_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 };
 
 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
  public:
-  TestWebURLLoaderClient(
-      ResourceDispatcher* dispatcher,
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner)
-      : loader_(
-          new WebURLLoaderImpl(
-              dispatcher,
-              make_scoped_ptr(new scheduler::WebTaskRunnerImpl(task_runner)))),
+  TestWebURLLoaderClient(ResourceDispatcher* dispatcher,
+                         scoped_refptr<scheduler::TaskQueue> task_runner)
+      : loader_(new WebURLLoaderImpl(
+            dispatcher,
+            make_scoped_ptr(new scheduler::WebTaskRunnerImpl(task_runner)))),
         expect_multipart_response_(false),
         delete_on_receive_redirect_(false),
         delete_on_receive_response_(false),
         delete_on_receive_data_(false),
         delete_on_finish_(false),
         delete_on_fail_(false),
         did_receive_redirect_(false),
         did_receive_response_(false),
         did_finish_(false) {}
 
@@ skipping 128 matching lines @@
   bool did_finish_;
   blink::WebURLError error_;
   blink::WebURLResponse response_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebURLLoaderClient);
 };
 
 class WebURLLoaderImplTest : public testing::Test {
  public:
   explicit WebURLLoaderImplTest()
-      : client_(&dispatcher_, message_loop_.task_runner()) {}
+      : worker_scheduler_(scheduler::WorkerScheduler::Create(
+            scheduler::SchedulerTqmDelegateImpl::Create(
+                &message_loop_,
+                make_scoped_ptr(new base::DefaultTickClock())))) {
+    worker_scheduler_->Init();
+    client_.reset(new TestWebURLLoaderClient(
+        &dispatcher_, worker_scheduler_->DefaultTaskRunner()));
+  }
+
   ~WebURLLoaderImplTest() override {}
 
   void DoStartAsyncRequest() {
     blink::WebURLRequest request;
     request.initialize();
     request.setURL(GURL(kTestURL));
     client()->loader()->loadAsynchronously(request, client());
     ASSERT_TRUE(peer());
   }
 
@@ skipping 86 matching lines @@
   }
 
   void DoReceiveDataMultipart() {
     peer()->OnReceivedData(make_scoped_ptr(
         new FixedReceivedData(kMultipartResponse, strlen(kMultipartResponse),
                               strlen(kMultipartResponse))));
     // Multipart delegate should modify the data the client sees.
     EXPECT_NE(kMultipartResponse, client()->received_data());
   }
 
-  TestWebURLLoaderClient* client() { return &client_; }
+  TestWebURLLoaderClient* client() { return client_.get(); }
   TestResourceDispatcher* dispatcher() { return &dispatcher_; }
   RequestPeer* peer() { return dispatcher()->peer(); }
   base::MessageLoop* message_loop() { return &message_loop_; }
 
  private:
   base::MessageLoop message_loop_;
+  // WorkerScheduler is needed because WebURLLoaderImpl needs a
+  // scheduler::TaskQueue.
+  scoped_ptr<scheduler::WorkerScheduler> worker_scheduler_;
   TestResourceDispatcher dispatcher_;
-  TestWebURLLoaderClient client_;
+  scoped_ptr<TestWebURLLoaderClient> client_;
 };
 
 TEST_F(WebURLLoaderImplTest, Success) {
   DoStartAsyncRequest();
   DoReceiveResponse();
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
@@ skipping 323 matching lines @@
   EXPECT_EQ(kMimeType, client()->response().mimeType().latin1());
 
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
   EXPECT_EQ(kTestData, client()->received_data());
 }
 
 }  // namespace
 }  // namespace content