Worker: Remove cross-thread PostTask functions from WorkerLoaderProxy

third_party/WebKit/Source/modules/websockets/WorkerWebSocketChannel.h

 /*
  * Copyright (C) 2011 Google Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WorkerWebSocketChannel_h
 #define WorkerWebSocketChannel_h
 
 #include <stdint.h>
 #include <memory>
 #include "bindings/core/v8/SourceLocation.h"
+#include "core/workers/ParentFrameTaskRunners.h"
 #include "core/workers/WorkerThreadLifecycleObserver.h"
 #include "modules/websockets/WebSocketChannel.h"
 #include "modules/websockets/WebSocketChannelClient.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/Assertions.h"
 #include "platform/wtf/Forward.h"
 #include "platform/wtf/RefPtr.h"
 #include "platform/wtf/Vector.h"
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/WebTraceLocation.h"
@@ skipping 42 matching lines @@
 
   class Bridge;
   // Allocated and used in the main thread.
   class Peer final : public GarbageCollectedFinalized<Peer>,
                      public WebSocketChannelClient,
                      public WorkerThreadLifecycleObserver {
     USING_GARBAGE_COLLECTED_MIXIN(Peer);
     WTF_MAKE_NONCOPYABLE(Peer);
 
    public:
-    Peer(Bridge*, PassRefPtr<WorkerLoaderProxy>, WorkerThreadLifecycleContext*);
+    Peer(Bridge*,
+         PassRefPtr<WorkerLoaderProxy>,
+         RefPtr<WebTaskRunner>,
+         WorkerThreadLifecycleContext*);
     ~Peer() override;
 
     // SourceLocation parameter may be shown when the connection fails.
     bool Initialize(std::unique_ptr<SourceLocation>, ThreadableLoadingContext*);
 
     bool Connect(const KURL&, const String& protocol);
     void SendTextAsCharVector(std::unique_ptr<Vector<char>>);
     void SendBinaryAsCharVector(std::unique_ptr<Vector<char>>);
     void SendBlob(PassRefPtr<BlobDataHandle>);
     void Close(int code, const String& reason);
@@ skipping 17 matching lines @@
                   unsigned short code,
                   const String& reason) override;
     void DidError() override;
 
     // WorkerThreadLifecycleObserver function.
     void ContextDestroyed(WorkerThreadLifecycleContext*) override;
 
    private:
     CrossThreadWeakPersistent<Bridge> bridge_;
     RefPtr<WorkerLoaderProxy> loader_proxy_;
+    RefPtr<WebTaskRunner> worker_networking_task_runner_;
     Member<WebSocketChannel> main_web_socket_channel_;
   };
 
   // Bridge for Peer. Running on the worker thread.
   class Bridge final : public GarbageCollectedFinalized<Bridge> {
     WTF_MAKE_NONCOPYABLE(Bridge);
 
    public:
     Bridge(WebSocketChannelClient*, WorkerGlobalScope&);
     ~Bridge();
 
     // SourceLocation parameter may be shown when the connection fails.
     bool Connect(std::unique_ptr<SourceLocation>,
                  const KURL&,
                  const String& protocol);
 
     void Send(const CString& message);
     void Send(const DOMArrayBuffer&,
               unsigned byte_offset,
               unsigned byte_length);
     void Send(PassRefPtr<BlobDataHandle>);
     void Close(int code, const String& reason);
     void Fail(const String& reason,
               MessageLevel,
               std::unique_ptr<SourceLocation>);
     void Disconnect();
 
     void ConnectOnMainThread(std::unique_ptr<SourceLocation>,
                              RefPtr<WorkerLoaderProxy>,
+                             RefPtr<WebTaskRunner>,
                              WorkerThreadLifecycleContext*,
                              const KURL&,
                              const String& protocol,
                              WebSocketChannelSyncHelper*);
 
     // Returns null when |disconnect| has already been called.
     WebSocketChannelClient* Client() { return client_; }
 
     DECLARE_TRACE();
     // Promptly clear connection to peer + loader proxy.
     EAGERLY_FINALIZE();
 
    private:
     Member<WebSocketChannelClient> client_;
     Member<WorkerGlobalScope> worker_global_scope_;
     RefPtr<WorkerLoaderProxy> loader_proxy_;
+    CrossThreadPersistent<ParentFrameTaskRunners> parent_frame_task_runners_;
     CrossThreadPersistent<Peer> peer_;
   };
 
  private:
   WorkerWebSocketChannel(WorkerGlobalScope&,
                          WebSocketChannelClient*,
                          std::unique_ptr<SourceLocation>);
 
   Member<Bridge> bridge_;
   std::unique_ptr<SourceLocation> location_at_connection_;
 };
 
 }  // namespace blink
 
 #endif  // WorkerWebSocketChannel_h