Revert of Add a WorkerScheduler and a WebThreadImplForWorker

content/child/threaded_data_provider.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/threaded_data_provider.h"
 
 #include "content/child/child_process.h"
 #include "content/child/child_thread_impl.h"
 #include "content/child/resource_dispatcher.h"
-#include "content/child/scheduler/webthread_impl_for_worker_scheduler.h"
 #include "content/child/thread_safe_sender.h"
+#include "content/child/webthread_impl.h"
 #include "content/common/resource_messages.h"
 #include "ipc/ipc_sync_channel.h"
 #include "third_party/WebKit/public/platform/WebThread.h"
 #include "third_party/WebKit/public/platform/WebThreadedDataReceiver.h"
 
 namespace content {
 
 namespace {
 
 class DataProviderMessageFilter : public IPC::MessageFilter {
  public:
   DataProviderMessageFilter(
       const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
       scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
-      const WebThreadImplForWorkerScheduler& background_thread,
+      const WebThreadImpl& background_thread,
       const base::WeakPtr<ThreadedDataProvider>&
           background_thread_resource_provider,
       const base::WeakPtr<ThreadedDataProvider>& main_thread_resource_provider,
       int request_id);
 
   // IPC::ChannelProxy::MessageFilter
   void OnFilterAdded(IPC::Sender* sender) final;
   bool OnMessageReceived(const IPC::Message& message) final;
 
  private:
   ~DataProviderMessageFilter() override {}
 
   void OnReceivedData(int request_id, int data_offset, int data_length,
                       int encoded_data_length);
 
   const scoped_refptr<base::MessageLoopProxy> io_message_loop_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
-  const WebThreadImplForWorkerScheduler& background_thread_;
+  const WebThreadImpl& background_thread_;
   // This weakptr can only be dereferenced on the background thread.
   base::WeakPtr<ThreadedDataProvider>
       background_thread_resource_provider_;
   // This weakptr can only be dereferenced on the main thread.
   base::WeakPtr<ThreadedDataProvider>
       main_thread_resource_provider_;
   int request_id_;
 };
 
 DataProviderMessageFilter::DataProviderMessageFilter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner,
-    const WebThreadImplForWorkerScheduler& background_thread,
+    const WebThreadImpl& background_thread,
     const base::WeakPtr<ThreadedDataProvider>&
         background_thread_resource_provider,
     const base::WeakPtr<ThreadedDataProvider>& main_thread_resource_provider,
     int request_id)
     : io_message_loop_(io_message_loop),
       main_thread_task_runner_(main_thread_task_runner),
       background_thread_(background_thread),
       background_thread_resource_provider_(background_thread_resource_provider),
       main_thread_resource_provider_(main_thread_resource_provider),
       request_id_(request_id) {
@@ skipping 51 matching lines @@
 
 ThreadedDataProvider::ThreadedDataProvider(
     int request_id,
     blink::WebThreadedDataReceiver* threaded_data_receiver,
     linked_ptr<base::SharedMemory> shm_buffer,
     int shm_size,
     scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner)
     : request_id_(request_id),
       shm_buffer_(shm_buffer),
       shm_size_(shm_size),
-      background_thread_(static_cast<WebThreadImplForWorkerScheduler&>(
+      background_thread_(static_cast<WebThreadImpl&>(
           *threaded_data_receiver->backgroundThread())),
       ipc_channel_(ChildThreadImpl::current()->channel()),
       threaded_data_receiver_(threaded_data_receiver),
       resource_filter_active_(false),
       main_thread_task_runner_(main_thread_task_runner),
       main_thread_weak_factory_(this) {
   DCHECK(ChildThreadImpl::current());
   DCHECK(ipc_channel_);
   DCHECK(threaded_data_receiver_);
   DCHECK(main_thread_task_runner_.get());
@@ skipping 39 matching lines @@
 
   // We can't destroy this instance directly; we need to bounce a message over
   // to the background thread and back to make sure nothing else will access it
   // there, before we can destruct it. We also need to make sure the background
   // thread is still alive, since Blink could have shut down at this point
   // and freed the thread.
   if (current_background_thread) {
     // We should never end up with a different parser thread than from when the
     // ThreadedDataProvider gets created.
     DCHECK(current_background_thread ==
-           static_cast<WebThreadImplForWorkerScheduler*>(&background_thread_));
+        static_cast<WebThreadImpl*>(&background_thread_));
     background_thread_.TaskRunner()->PostTask(
         FROM_HERE, base::Bind(&ThreadedDataProvider::StopOnBackgroundThread,
                               base::Unretained(this)));
   }
 }
 
 void ThreadedDataProvider::StopOnBackgroundThread() {
   DCHECK(background_thread_.isCurrentThread());
   DCHECK(background_thread_weak_factory_);
 
@@ skipping 138 matching lines @@
     DCHECK(threaded_data_receiver_->needsMainthreadDataCopy());
     DCHECK_EQ((size_t)data_length, data_copy->size());
   }
 
   threaded_data_receiver_->acceptMainthreadDataNotification(
       (data_copy && !data_copy->empty()) ? &data_copy->front() : NULL,
       data_length, encoded_data_length);
 }
 
 }  // namespace content