Turn WorkerLoaderProxy into a threadsafe, ref-counted object.

Source/core/workers/WorkerLoaderProxy.h

 /*
  * Copyright (C) 2009 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 WorkerLoaderProxy_h
 #define WorkerLoaderProxy_h
 
 #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;
 
     // Posts callbacks from loading code to the WorkerGlobalScope.
     // Returns true if the task was posted successfully.
     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