scheduler: Move the Blink scheduler into Blink

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/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_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/child/sync_load_response.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/host_port_pair.h"
 #include "net/base/net_errors.h"
@@ skipping 77 matching lines @@
   bool defers_loading_;
   GURL url_;
   GURL stream_url_;
   SyncLoadResponse sync_load_response_;
 
   DISALLOW_COPY_AND_ASSIGN(TestResourceDispatcher);
 };
 
 class TestWebURLLoaderClient : public blink::WebURLLoaderClient {
  public:
-  TestWebURLLoaderClient(ResourceDispatcher* dispatcher,
-                         scoped_refptr<scheduler::TaskQueue> task_runner)
-      : loader_(new WebURLLoaderImpl(
-            dispatcher,
-            base::WrapUnique(new scheduler::WebTaskRunnerImpl(task_runner)))),
+  TestWebURLLoaderClient(ResourceDispatcher* dispatcher)
+      : loader_(new WebURLLoaderImpl(dispatcher)),
         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),
         check_redirect_request_priority_(false),
         did_finish_(false) {}
 
@@ skipping 132 matching lines @@
   std::string received_data_;
   bool did_finish_;
   blink::WebURLError error_;
   blink::WebURLResponse response_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebURLLoaderClient);
 };
 
 class WebURLLoaderImplTest : public testing::Test {
  public:
-  explicit WebURLLoaderImplTest()
-      : worker_scheduler_(scheduler::WorkerScheduler::Create(
-            scheduler::SchedulerTqmDelegateImpl::Create(
-                &message_loop_,
-                base::WrapUnique(new base::DefaultTickClock())))) {
-    worker_scheduler_->Init();
-    client_.reset(new TestWebURLLoaderClient(
-        &dispatcher_, worker_scheduler_->DefaultTaskRunner()));
+  WebURLLoaderImplTest() {
+    client_.reset(new TestWebURLLoaderClient(&dispatcher_));
   }
 
   ~WebURLLoaderImplTest() override {}
 
   void DoStartAsyncRequest() {
     blink::WebURLRequest request;
     request.setURL(GURL(kTestURL));
     client()->loader()->loadAsynchronously(request, client());
     ASSERT_TRUE(peer());
   }
@@ skipping 69 matching lines @@
     EXPECT_NE(kFtpDirListing, client()->received_data());
   }
 
   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.
-  std::unique_ptr<scheduler::WorkerScheduler> worker_scheduler_;
   TestResourceDispatcher dispatcher_;
   std::unique_ptr<TestWebURLLoaderClient> client_;
 };
 
 TEST_F(WebURLLoaderImplTest, Success) {
   DoStartAsyncRequest();
   DoReceiveResponse();
   DoReceiveData();
   DoCompleteRequest();
   EXPECT_FALSE(dispatcher()->canceled());
@@ skipping 319 matching lines @@
                                         encoded_data_length);
 
   EXPECT_EQ(kEncodedBodyLength, response.encodedBodyLength());
   EXPECT_EQ(kEncodedDataLength, encoded_data_length);
   int expected_decoded_body_length = strlen(kBodyData);
   EXPECT_EQ(expected_decoded_body_length, response.decodedBodyLength());
 }
 
 }  // namespace
 }  // namespace content