Propagate proper FROM_HERE to postTask() in worker code

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 119 matching lines @@
 
         WorkerLoaderProxy* loaderProxy()
         {
             return m_loaderProxy.get();
         }
 
     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;
+        virtual void forwardTaskToWorker(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>) = 0;
+        virtual void forwardTaskToWorkerOnLoaderDone(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>) = 0;
 
         // 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*);
 
         // Only to be used on the main thread.
         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;
+        void forwardTaskToWorker(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>) override;
+        void forwardTaskToWorkerOnLoaderDone(const WebTraceLocation&, 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:
+        struct ClientTask {
+            WebTraceLocation m_location;
+            std::unique_ptr<ExecutionContextTask> m_task;
+
+            ClientTask(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>);
+            ~ClientTask();
+
+            ClientTask(ClientTask&&);
+        };
+
         ~MainThreadSyncBridge() override;
 
-        void forwardTaskToWorker(std::unique_ptr<ExecutionContextTask>) override;
-        void forwardTaskToWorkerOnLoaderDone(std::unique_ptr<ExecutionContextTask>) override;
+        void forwardTaskToWorker(const WebTraceLocation&, std::unique_ptr<ExecutionContextTask>) override;
+        void forwardTaskToWorkerOnLoaderDone(const WebTraceLocation&, 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;
+        Vector<ClientTask> m_clientTasks;
         Mutex m_lock;
     };
 
     WorkerThreadableLoader(WorkerGlobalScope&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&, BlockingBehavior);
 
     Persistent<WorkerGlobalScope> m_workerGlobalScope;
     const Persistent<ThreadableLoaderClientWrapper> m_workerClientWrapper;
 
     MainThreadBridgeBase* m_bridge;
 };
 
 } // namespace blink
 
 #endif // WorkerThreadableLoader_h