Home | History | Annotate | Download | only in web 
      1 /*
      2  * Copyright (C) 2009 Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #ifndef WebSharedWorkerImpl_h
     32 #define WebSharedWorkerImpl_h
     33 
     34 #include "public/web/WebSharedWorker.h"
     35 
     36 #include "core/dom/ExecutionContext.h"
     37 #include "core/workers/WorkerLoaderProxy.h"
     38 #include "core/workers/WorkerReportingProxy.h"
     39 #include "core/workers/WorkerScriptLoaderClient.h"
     40 #include "core/workers/WorkerThread.h"
     41 #include "public/web/WebContentSecurityPolicy.h"
     42 #include "public/web/WebFrameClient.h"
     43 #include "public/web/WebSharedWorkerClient.h"
     44 #include "wtf/PassOwnPtr.h"
     45 #include "wtf/RefPtr.h"
     46 #include "wtf/WeakPtr.h"
     47 
     48 namespace blink {
     49 
     50 class ConsoleMessage;
     51 class ResourceResponse;
     52 class WebApplicationCacheHost;
     53 class WebApplicationCacheHostClient;
     54 class WebWorkerClient;
     55 class WebSecurityOrigin;
     56 class WebString;
     57 class WebURL;
     58 class WebView;
     59 class WebWorker;
     60 class WebSharedWorkerClient;
     61 class WorkerInspectorProxy;
     62 
     63 // This class is used by the worker process code to talk to the SharedWorker implementation.
     64 // It can't use it directly since it uses WebKit types, so this class converts the data types.
     65 // When the SharedWorker object wants to call WorkerReportingProxy, this class will
     66 // convert to Chrome data types first and then call the supplied WebCommonWorkerClient.
     67 class WebSharedWorkerImpl FINAL
     68     : public WorkerReportingProxy
     69     , public WorkerLoaderProxy
     70     , public WebFrameClient
     71     , public WebSharedWorker {
     72 public:
     73     explicit WebSharedWorkerImpl(WebSharedWorkerClient*);
     74 
     75     // WorkerReportingProxy methods:
     76     virtual void reportException(
     77         const WTF::String&, int, int, const WTF::String&) OVERRIDE;
     78     virtual void reportConsoleMessage(PassRefPtrWillBeRawPtr<ConsoleMessage>) OVERRIDE;
     79     virtual void postMessageToPageInspector(const WTF::String&) OVERRIDE;
     80     virtual void updateInspectorStateCookie(const WTF::String&) OVERRIDE;
     81     virtual void workerGlobalScopeStarted(WorkerGlobalScope*) OVERRIDE;
     82     virtual void workerGlobalScopeClosed() OVERRIDE;
     83     virtual void workerThreadTerminated() OVERRIDE;
     84     virtual void willDestroyWorkerGlobalScope() OVERRIDE { }
     85 
     86     // WorkerLoaderProxy methods:
     87     virtual void postTaskToLoader(PassOwnPtr<ExecutionContextTask>) OVERRIDE;
     88     virtual bool postTaskToWorkerGlobalScope(PassOwnPtr<ExecutionContextTask>) OVERRIDE;
     89 
     90     // WebFrameClient methods to support resource loading thru the 'shadow page'.
     91     virtual WebApplicationCacheHost* createApplicationCacheHost(WebLocalFrame*, WebApplicationCacheHostClient*) OVERRIDE;
     92     virtual void didFinishDocumentLoad(WebLocalFrame*) OVERRIDE;
     93 
     94     // WebSharedWorker methods:
     95     virtual void startWorkerContext(const WebURL&, const WebString& name, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType) OVERRIDE;
     96     virtual void connect(WebMessagePortChannel*) OVERRIDE;
     97     virtual void terminateWorkerContext() OVERRIDE;
     98     virtual void clientDestroyed() OVERRIDE;
     99 
    100     virtual void pauseWorkerContextOnStart() OVERRIDE;
    101     virtual void resumeWorkerContext() OVERRIDE;
    102     // FIXME: Remove this once chromium uses the one that receives hostId as a parameter.
    103     virtual void attachDevTools() OVERRIDE;
    104     virtual void attachDevTools(const WebString& hostId) OVERRIDE;
    105     // FIXME: Remove this once chromium uses the one that receives hostId as a parameter.
    106     virtual void reattachDevTools(const WebString& savedState) OVERRIDE;
    107     virtual void reattachDevTools(const WebString& hostId, const WebString& savedState) OVERRIDE;
    108     virtual void detachDevTools() OVERRIDE;
    109     virtual void dispatchDevToolsMessage(const WebString&) OVERRIDE;
    110 
    111 private:
    112     class Loader;
    113 
    114     virtual ~WebSharedWorkerImpl();
    115 
    116     WebSharedWorkerClient* client() { return m_client->get(); }
    117 
    118     void setWorkerThread(PassRefPtr<WorkerThread> thread) { m_workerThread = thread; }
    119     WorkerThread* workerThread() { return m_workerThread.get(); }
    120 
    121     // Shuts down the worker thread.
    122     void stopWorkerThread();
    123 
    124     // Creates the shadow loader used for worker network requests.
    125     void initializeLoader(const WebURL&);
    126 
    127     void didReceiveScriptLoaderResponse();
    128     void onScriptLoaderFinished();
    129 
    130     static void connectTask(ExecutionContext*, PassOwnPtr<WebMessagePortChannel>);
    131     // Tasks that are run on the main thread.
    132     void workerGlobalScopeClosedOnMainThread();
    133     void workerThreadTerminatedOnMainThread();
    134 
    135     void postMessageToPageInspectorOnMainThread(const String& message);
    136 
    137     // 'shadow page' - created to proxy loading requests from the worker.
    138     RefPtrWillBePersistent<ExecutionContext> m_loadingDocument;
    139     WebView* m_webView;
    140     WebFrame* m_mainFrame;
    141     bool m_askedToTerminate;
    142 
    143     OwnPtr<WorkerInspectorProxy> m_workerInspectorProxy;
    144 
    145     RefPtr<WorkerThread> m_workerThread;
    146 
    147     // This one's initialized and bound to the main thread.
    148     RefPtr<WeakReference<WebSharedWorkerClient> > m_client;
    149 
    150     // Usually WeakPtr is created by WeakPtrFactory exposed by Client
    151     // class itself, but here it's implemented by Chrome so we create
    152     // our own WeakPtr.
    153     WeakPtr<WebSharedWorkerClient> m_clientWeakPtr;
    154 
    155     bool m_pauseWorkerContextOnStart;
    156     bool m_attachDevToolsOnStart;
    157 
    158     // Kept around only while main script loading is ongoing.
    159     OwnPtr<Loader> m_mainScriptLoader;
    160     WebURL m_url;
    161     WebString m_name;
    162     WebString m_contentSecurityPolicy;
    163     WebContentSecurityPolicyType m_policyType;
    164 };
    165 
    166 } // namespace blink
    167 
    168 #endif
    169