Worker: Remove WorkerLoaderProxy for clean-up

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 35 matching lines @@
 #include "platform/wtf/text/WTFString.h"
 #include "public/platform/WebTraceLocation.h"
 
 namespace blink {
 
 class BlobDataHandle;
 class KURL;
 class ThreadableLoadingContext;
 class WebSocketChannelSyncHelper;
 class WorkerGlobalScope;
-class WorkerLoaderProxy;
 
 class WorkerWebSocketChannel final : public WebSocketChannel {
   WTF_MAKE_NONCOPYABLE(WorkerWebSocketChannel);
 
  public:
   static WebSocketChannel* Create(WorkerGlobalScope& worker_global_scope,
                                   WebSocketChannelClient* client,
                                   std::unique_ptr<SourceLocation> location) {
     return new WorkerWebSocketChannel(worker_global_scope, client,
                                       std::move(location));
@@ skipping 24 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>,
          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>>);
@@ skipping 18 matching lines @@
     void DidClose(ClosingHandshakeCompletionStatus,
                   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>,
+                             ThreadableLoadingContext*,
                              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