Implement the infrastructure of creating WorkerFetchContext in worker global scope.

content/child/resource_dispatcher.h

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #ifndef CONTENT_CHILD_RESOURCE_DISPATCHER_H_
 #define CONTENT_CHILD_RESOURCE_DISPATCHER_H_
 
 #include <stdint.h>
@@ skipping 42 matching lines @@
 class URLLoaderFactory;
 }  // namespace mojom
 
 // This class serves as a communication interface to the ResourceDispatcherHost
 // in the browser process. It can be used from any child process.
 // Virtual methods are for tests.
 class CONTENT_EXPORT ResourceDispatcher : public IPC::Listener {
  public:
   ResourceDispatcher(
       IPC::Sender* sender,
-      scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner);
+      scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner);
   ~ResourceDispatcher() override;
 
   // IPC::Listener implementation.
   bool OnMessageReceived(const IPC::Message& message) override;
 
   // Call this method to load the resource synchronously (i.e., in one shot).
   // This is an alternative to the StartAsync method. Be warned that this method
   // will block the calling thread until the resource is fully downloaded or an
   // error occurs. It could block the calling thread for a long time, so only
   // use this if you really need it!  There is also no way for the caller to
@@ skipping 54 matching lines @@
   // delegate have a longer lifetime than the ResourceDispatcher.
   void set_delegate(ResourceDispatcherDelegate* delegate) {
     delegate_ = delegate;
   }
 
   // Remembers IO thread timestamp for next resource message.
   void set_io_timestamp(base::TimeTicks io_timestamp) {
     io_timestamp_ = io_timestamp;
   }
 
-  void SetMainThreadTaskRunner(
-      scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner) {
-    main_thread_task_runner_ = main_thread_task_runner;
+  void SetThreadTaskRunner(
+      scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner) {
+    thread_task_runner_ = thread_task_runner;
   }
 
   void SetResourceSchedulingFilter(
       scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter);
 
   base::WeakPtr<ResourceDispatcher> GetWeakPtr() {
     return weak_factory_.GetWeakPtr();
   }
 
   void OnTransferSizeUpdated(int request_id, int32_t transfer_size_diff);
@@ skipping 113 matching lines @@
   IPC::Sender* message_sender_;
 
   // All pending requests issued to the host
   PendingRequestMap pending_requests_;
 
   ResourceDispatcherDelegate* delegate_;
 
   // IO thread timestamp for ongoing IPC message.
   base::TimeTicks io_timestamp_;
 
-  scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner_;
   scoped_refptr<ResourceSchedulingFilter> resource_scheduling_filter_;
 
   base::WeakPtrFactory<ResourceDispatcher> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_RESOURCE_DISPATCHER_H_