Turn WorkerLoaderProxy into a threadsafe, ref-counted object.

Source/core/workers/WorkerLoaderProxy.h

Index: Source/core/workers/WorkerLoaderProxy.h
diff --git a/Source/core/workers/WorkerLoaderProxy.h b/Source/core/workers/WorkerLoaderProxy.h
index 21e5dd4e3f2d178e0324328446cd0951280ff3fb..8289361d560c0e059da71506af355c5bcd82a29e 100644
--- a/Source/core/workers/WorkerLoaderProxy.h
+++ b/Source/core/workers/WorkerLoaderProxy.h
@@ -34,17 +34,26 @@
 #include "core/dom/ExecutionContext.h"
 #include "wtf/Forward.h"
 #include "wtf/PassOwnPtr.h"
+#include "wtf/ThreadSafeRefCounted.h"
 
 namespace blink {
 
-// A proxy to talk to the loader context. Normally, the document on the main thread
-// provides loading services for the subordinate workers. This interface provides 2-way
-// communications to the Document context and back to the worker.
+// The WorkerLoaderProxy is a proxy to the loader context. Normally, the
+// document on the main thread provides loading services for the subordinate
+// workers. WorkerLoaderProxy provides 2-way communications to the Document
+// context and back to the worker.
+//
 // Note that in multi-process browsers, the Worker object context and the Document
 // context can be distinct.
-class WorkerLoaderProxy {
+
+// The abstract interface providing the methods for actually posting tasks; separated
+// from the thread-safe & ref-counted WorkerLoaderProxy object which weakly refers
+// to the provider so as to allow the proxy object to outlive the provider during
+// shutdown.
+//
+class WorkerLoaderProxyProvider {
 public:
-    virtual ~WorkerLoaderProxy() { }
+    virtual ~WorkerLoaderProxyProvider() { }
 
     // Posts a task to the thread which runs the loading code (normally, the main thread).
     virtual void postTaskToLoader(PassOwnPtr<ExecutionContextTask>) = 0;
@@ -54,6 +63,29 @@ public:
     virtual bool postTaskToWorkerGlobalScope(PassOwnPtr<ExecutionContextTask>) = 0;
 };
 
+class WorkerLoaderProxy : public ThreadSafeRefCounted<WorkerLoaderProxy>, public WorkerLoaderProxyProvider {
+public:
+    static PassRefPtr<WorkerLoaderProxy> create(WorkerLoaderProxyProvider* loaderProxyProvider)
+    {
+        return adoptRef(new WorkerLoaderProxy(loaderProxyProvider));
+    }
+
+    ~WorkerLoaderProxy() override;
+
+    void postTaskToLoader(PassOwnPtr<ExecutionContextTask>) override;
+    bool postTaskToWorkerGlobalScope(PassOwnPtr<ExecutionContextTask>) override;
+
+    // Notification from the provider that it must
+    // no longer be accessed.

[kinuko, 2015/02/05 01:41:16]

Can we make this comment more explicit (and maybe make it a class-level comment)
to note that provider implementor or provider holder must call this before
destructing the provider?

[sof, 2015/02/05 08:05:27]

Yes, the comments here were a bit outdated overall. Updated and made the
requirement clear wrt detachProvider().

(If anyone can come up with better naming than "Provider", please change.)

+    void detachProvider(WorkerLoaderProxyProvider*);
+
+private:
+    explicit WorkerLoaderProxy(WorkerLoaderProxyProvider*);
+
+    Mutex m_lock;
+    WorkerLoaderProxyProvider* m_loaderProxyProvider;
+};
+
 } // namespace blink
 
 #endif // WorkerLoaderProxy_h