Move WorkerThreadable internal classes to Oilpan heap

third_party/WebKit/Source/core/loader/WorkerThreadableLoader.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 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (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 WorkerThreadableLoader_h
 #define WorkerThreadableLoader_h
 
+#include "core/dom/ExecutionContextTask.h"
 #include "core/loader/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/loader/ThreadableLoaderClientWrapper.h"
+#include "core/workers/WorkerThread.h"
+#include "core/workers/WorkerThreadLifecycleObserver.h"
+#include "platform/WaitableEvent.h"
 #include "platform/heap/Handle.h"
-#include "platform/weborigin/Referrer.h"
-#include "wtf/Functional.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Threading.h"
-#include "wtf/ThreadingPrimitives.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
 #include <memory>
 
 namespace blink {
 
-class ExecutionContextTask;
 class ResourceError;
 class ResourceRequest;
 class ResourceResponse;
-class WaitableEvent;
 class WorkerGlobalScope;
 class WorkerLoaderProxy;
 struct CrossThreadResourceRequestData;
 
 class WorkerThreadableLoader final : public ThreadableLoader {
     USING_FAST_MALLOC(WorkerThreadableLoader);
 public:
     static void loadResourceSynchronously(WorkerGlobalScope&, const ResourceRequest&, ThreadableLoaderClient&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
     static std::unique_ptr<WorkerThreadableLoader> create(WorkerGlobalScope& workerGlobalScope, ThreadableLoaderClient* client, const ThreadableLoaderOptions& options, const ResourceLoaderOptions& resourceLoaderOptions)
     {
         return wrapUnique(new WorkerThreadableLoader(workerGlobalScope, client, options, resourceLoaderOptions, LoadAsynchronously));
     }
 
     ~WorkerThreadableLoader() override;
 
     void start(const ResourceRequest&) override;
-
     void overrideTimeout(unsigned long timeout) override;
-
     void cancel() override;
 
 private:
     enum BlockingBehavior {
         LoadSynchronously,
         LoadAsynchronously
     };
 
-    // Creates a loader on the main thread and bridges communication between
-    // the main thread and the worker context's thread where WorkerThreadableLoader runs.
-    //
-    // Regarding the bridge and lifetimes of items used in callbacks, there are a few cases:
-    //
-    // all cases. All tasks posted from the worker context's thread are ok because
-    //    the last task posted always is "mainThreadDestroy", so MainThreadBridge is
-    //    around for all tasks that use it on the main thread.
-    //
-    // case 1. worker.terminate is called.
-    //    In this case, no more tasks are posted from the worker object's thread to the worker
-    //    context's thread -- WorkerGlobalScopeProxy implementation enforces this.
-    //
-    // case 2. xhr gets aborted and the worker context continues running.
-    //    The ThreadableLoaderClientWrapper has the underlying client cleared, so no more calls
-    //    go through it.  All tasks posted from the worker object's thread to the worker context's
-    //    thread do "ThreadableLoaderClientWrapper::ref" (automatically inside of the cross thread copy
-    //    done in createCrossThreadTask), so the ThreadableLoaderClientWrapper instance is there until all
-    //    tasks are executed.
-    class MainThreadBridgeBase : public ThreadableLoaderClient {
+    // A TaskForwarder forwards an ExecutionContextTask to the worker thread.
+    class TaskForwarder : public GarbageCollectedFinalized<TaskForwarder> {
     public:
-        // All executed on the worker context's thread.
-        MainThreadBridgeBase(ThreadableLoaderClientWrapper*, PassRefPtr<WorkerLoaderProxy>);
-        virtual void start(const ResourceRequest&, const WorkerGlobalScope&) = 0;
+        virtual ~TaskForwarder() {}
+        virtual void forwardTask(std::unique_ptr<ExecutionContextTask>) = 0;
+        virtual void forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask>) = 0;
+        virtual void abort() = 0;
+
+        DEFINE_INLINE_VIRTUAL_TRACE() {}
+    };
+
+    class AsyncTaskForwarder final : public TaskForwarder {
+    public:
+        explicit AsyncTaskForwarder(PassRefPtr<WorkerLoaderProxy>);
+        ~AsyncTaskForwarder() override;
+
+        void forwardTask(std::unique_ptr<ExecutionContextTask>) override;
+        void forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask>) override;
+        void abort() override;
+
+    private:
+        RefPtr<WorkerLoaderProxy> m_loaderProxy;
+    };
+
+    // All observing functions must be called after |wait()| returns, and all
+    // setting functions must be called before |signal()| is called.
+    class WaitableEventWithTasks final : public ThreadSafeRefCounted<WaitableEventWithTasks> {
+    public:
+        static PassRefPtr<WaitableEventWithTasks> create() { return adoptRef(new WaitableEventWithTasks); }
+        ~WaitableEventWithTasks();
+
+        void signal();
+        void wait();
+
+        // Observing functions
+        bool isAborted() const { return m_isAborted; }
+        Vector<std::unique_ptr<ExecutionContextTask>> take();
+
+        // Setting functions
+        void append(std::unique_ptr<ExecutionContextTask>);
+        void setIsAborted() { m_isAborted = true; }
+
+    private:
+        WaitableEventWithTasks() {}
+
+        WaitableEvent m_event;
+        Vector<std::unique_ptr<ExecutionContextTask>> m_tasks;
+        bool m_isAborted = false;
+    };
+
+    class SyncTaskForwarder final : public TaskForwarder {
+    public:
+        explicit SyncTaskForwarder(PassRefPtr<WaitableEventWithTasks>);
+        ~SyncTaskForwarder() override;
+
+        void forwardTask(std::unique_ptr<ExecutionContextTask>) override;
+        void forwardTaskWithDoneSignal(std::unique_ptr<ExecutionContextTask>) override;
+        void abort() override;
+
+    private:
+        RefPtr<WaitableEventWithTasks> m_eventWithTasks;
+    };
+
+    class Peer;
+    // A Bridge instance lives in the worker thread and asks loading tasks the
+    // associated Peer object which lives in the main thread.
+    class Bridge final : public GarbageCollectedFinalized<Bridge> {
+    public:
+        Bridge(ThreadableLoaderClientWrapper*, PassRefPtr<WorkerLoaderProxy>, const ThreadableLoaderOptions&, const ResourceLoaderOptions&, BlockingBehavior);
+        ~Bridge();
+
+        void start(const ResourceRequest&, const WorkerGlobalScope&);
         void overrideTimeout(unsigned long timeoutMilliseconds);
         void cancel();
         void destroy();
 
-        // All executed on the main thread.
-        void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) final;
-        void didReceiveResponse(unsigned long identifier, const ResourceResponse&, std::unique_ptr<WebDataConsumerHandle>) final;
-        void didReceiveData(const char*, unsigned dataLength) final;
-        void didDownloadData(int dataLength) final;
-        void didReceiveCachedMetadata(const char*, int dataLength) final;
-        void didFinishLoading(unsigned long identifier, double finishTime) final;
-        void didFail(const ResourceError&) final;
-        void didFailAccessControlCheck(const ResourceError&) final;
-        void didFailRedirectCheck() final;
-        void didReceiveResourceTiming(const ResourceTimingInfo&) final;
+        void didStart(Peer*);
 
-    protected:
-        ~MainThreadBridgeBase() override;
+        // These getter functions are thread safe.
+        ThreadableLoaderClientWrapper* clientWrapper() { return m_clientWrapper.get(); }
+        const ThreadableLoaderOptions& threadableLoaderOptions() const { return m_threadableLoaderOptions; }
+        const ResourceLoaderOptions& resourceLoaderOptions() const { return m_resourceLoaderOptions; }
 
-        // Posts a task to the main thread to run mainThreadCreateLoader().
-        void createLoaderInMainThread(const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
-        // Posts a task to the main thread to run mainThreadStart();
-        void startInMainThread(const ResourceRequest&, const WorkerGlobalScope&);
-
-        WorkerLoaderProxy* loaderProxy()
-        {
-            return m_loaderProxy.get();
-        }
+        DECLARE_VIRTUAL_TRACE();
 
     private:
-        // The following methods are overridden by the subclasses to implement
-        // code to forward did.* method invocations to the worker context's
-        // thread which is specialized for sync and async case respectively.
-        virtual void forwardTaskToWorker(std::unique_ptr<ExecutionContextTask>) = 0;
-        virtual void forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask>) = 0;
+        const Member<ThreadableLoaderClientWrapper> m_clientWrapper;
+        const RefPtr<WorkerLoaderProxy> m_loaderProxy;
+        const ThreadableLoaderOptions m_threadableLoaderOptions;
+        const ResourceLoaderOptions m_resourceLoaderOptions;
+        const BlockingBehavior m_blockingBehavior;
 
-        // All executed on the main thread.
-        void mainThreadCreateLoader(ThreadableLoaderOptions, ResourceLoaderOptions, ExecutionContext*);
-        void mainThreadStart(std::unique_ptr<CrossThreadResourceRequestData>);
-        void mainThreadDestroy(ExecutionContext*);
-        void mainThreadOverrideTimeout(unsigned long timeoutMilliseconds, ExecutionContext*);
-        void mainThreadCancel(ExecutionContext*);
+        // |*m_peer| lives in the main thread.
+        CrossThreadPersistent<Peer> m_peer;
+    };
 
-        // Only to be used on the main thread.
+    // A Peer instance lives in the main thread. It is a ThreadableLoaderClient
+    // for a DocumentThreadableLoader and forward notifications to the
+    // ThreadableLoaderClientWrapper which lives in the worker thread.
+    class Peer final : public GarbageCollectedFinalized<Peer>, public ThreadableLoaderClient, public WorkerThreadLifecycleObserver {
+        USING_GARBAGE_COLLECTED_MIXIN(Peer);
+    public:
+        static void createAndStart(
+            Bridge*,
+            PassRefPtr<WorkerLoaderProxy>,
+            WorkerThreadLifecycleContext*,
+            std::unique_ptr<CrossThreadResourceRequestData>,
+            const ThreadableLoaderOptions&,
+            const ResourceLoaderOptions&,
+            PassRefPtr<WaitableEventWithTasks>,
+            ExecutionContext*);
+        ~Peer() override;
+
+        void overrideTimeout(unsigned long timeoutMillisecond);
+        void cancel();
+
+        void didSendData(unsigned long long bytesSent, unsigned long long totalBytesToBeSent) override;
+        void didReceiveResponse(unsigned long identifier, const ResourceResponse&, std::unique_ptr<WebDataConsumerHandle>) override;
+        void didReceiveData(const char*, unsigned dataLength) override;
+        void didDownloadData(int dataLength) override;
+        void didReceiveCachedMetadata(const char*, int dataLength) override;
+        void didFinishLoading(unsigned long identifier, double finishTime) override;
+        void didFail(const ResourceError&) override;
+        void didFailAccessControlCheck(const ResourceError&) override;
+        void didFailRedirectCheck() override;
+        void didReceiveResourceTiming(const ResourceTimingInfo&) override;
+
+        void contextDestroyed() override;
+
+        DECLARE_TRACE();
+
+    private:
+        Peer(TaskForwarder*, WorkerThreadLifecycleContext*);
+        void start(Document&, std::unique_ptr<CrossThreadResourceRequestData>, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
+
+        Member<TaskForwarder> m_forwarder;
         std::unique_ptr<ThreadableLoader> m_mainThreadLoader;
 
-        // |m_workerClientWrapper| holds an pointer created on the worker
-        // thread, and |this| instance is created on the main thread.
-        CrossThreadPersistent<ThreadableLoaderClientWrapper> m_workerClientWrapper;
-
-        // Used on the worker context thread.
-        RefPtr<WorkerLoaderProxy> m_loaderProxy;
-    };
-
-    class MainThreadAsyncBridge final : public MainThreadBridgeBase {
-    public:
-        MainThreadAsyncBridge(WorkerGlobalScope&, ThreadableLoaderClientWrapper*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
-        void start(const ResourceRequest&, const WorkerGlobalScope&) override;
-
-    private:
-        ~MainThreadAsyncBridge() override;
-
-        void forwardTaskToWorker(std::unique_ptr<ExecutionContextTask>) override;
-        void forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask>) override;
-    };
-
-    class MainThreadSyncBridge final : public MainThreadBridgeBase {
-    public:
-        MainThreadSyncBridge(WorkerGlobalScope&, ThreadableLoaderClientWrapper*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&);
-        void start(const ResourceRequest&, const WorkerGlobalScope&) override;
-
-    private:
-        ~MainThreadSyncBridge() override;
-
-        void forwardTaskToWorker(std::unique_ptr<ExecutionContextTask>) override;
-        void forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask>) override;
-
-        bool m_done;
-        std::unique_ptr<WaitableEvent> m_loaderDoneEvent;
-        // Thread-safety: |m_clientTasks| can be written (i.e. Closures are added)
-        // on the main thread only before |m_loaderDoneEvent| is signaled and can be read
-        // on the worker context thread only after |m_loaderDoneEvent| is signaled.
-        Vector<std::unique_ptr<ExecutionContextTask>> m_clientTasks;
-        Mutex m_lock;
+        // |*m_clientWrapper| lives in the worker thread.
+        CrossThreadWeakPersistent<ThreadableLoaderClientWrapper> m_clientWrapper;

[haraken, 2016/07/21 10:22:29]

Does this need to be a weak pointer?

[yhirano, 2016/07/21 10:56:09]

Having this as a strong persistent may form a reference cycle (if/when we hold
ThreadableLoaderClientWrapper::m_client as a Member).

I made worker->main cross thread persistent pointers strong and main->worker
pointers weak, but I'm not 100% sure it's the right pattern.

[haraken, 2016/07/21 15:56:14]

I want to confirm two things:

- Even if we use a strong reference and create a cycle, it won't be a problem
because the main->worker strong reference is explicitly broken when
WorkerContextLifecycleObserver::contextDestroyed is called, right?

- Who guarantees that ThreadableLoaderClientWrapper is kept alive while Peer is
holding a weak reference to the ThreadableLoaderClientWrapper?

[yhirano, 2016/07/22 04:42:14]

contextDestroyed is called at the worker thread termination, so the loop will
eventually break.
It's WorkerThreadableLoader. A WorkerThreadableLoader has a
ThreadableLoaderClientWrapper as Persistent. I will replace the Persistent with
Member in a later CL.

When ThreadableLoader is moved to Oilpan heap, users will expect there is a
strong member reference or weak reference from a ThreadableLoader to its client
(I'm not sure which is correct right now). Users won't expect there is a strong
persistent reference from a ThreadableLoader to its client, I think.

[haraken, 2016/07/22 08:57:30]

Makes sense.

Once we move ThreadableLoader to Oilpan's heap, we can just use strong
references (Member<>s). Cycles between Member<>s is not problematic at all.

In this CL, strong or weak wouldn't matter in practice. I'd slightly prefer
using a strong reference because then we can get rid of if(!clientWrapper) check
from a bunch of methods. We anyway need to get rid of the checks when we change
the reference to Member<> in the next CL. It looks simpler to use a strong
reference from the beginning.

     };
 
     WorkerThreadableLoader(WorkerGlobalScope&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&, BlockingBehavior);
 
     Persistent<WorkerGlobalScope> m_workerGlobalScope;
     const Persistent<ThreadableLoaderClientWrapper> m_workerClientWrapper;
-
-    MainThreadBridgeBase* m_bridge;
+    const Persistent<Bridge> m_bridge;
 };
 
 } // namespace blink
 
 #endif // WorkerThreadableLoader_h