SharedWorker: Factor out WorkerReportingProxy impl from WebSharedWorkerImpl

third_party/WebKit/Source/web/WebSharedWorkerImpl.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 18 matching lines @@
  */
 
 #ifndef WebSharedWorkerImpl_h
 #define WebSharedWorkerImpl_h
 
 #include "public/web/WebSharedWorker.h"
 
 #include <memory>
 #include "core/dom/ExecutionContext.h"
 #include "core/workers/WorkerLoaderProxy.h"
-#include "core/workers/WorkerReportingProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "public/platform/WebAddressSpace.h"
 #include "public/platform/WebContentSecurityPolicy.h"
 #include "public/web/WebDevToolsAgentClient.h"
 #include "public/web/WebFrameClient.h"
 #include "public/web/WebSharedWorkerClient.h"
+#include "web/WebSharedWorkerReportingProxyImpl.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
 
 class ParentFrameTaskRunners;
 class WebApplicationCacheHost;
 class WebApplicationCacheHostClient;
 class WebLocalFrameImpl;
 class WebServiceWorkerNetworkProvider;
 class WebSharedWorkerClient;
 class WebString;
 class WebURL;
 class WebView;
 class WorkerInspectorProxy;
 class WorkerScriptLoader;
 
 // This class is used by the worker process code to talk to the SharedWorker
-// implementation.
-// It can't use it directly since it uses WebKit types, so this class converts
-// the data types.  When the SharedWorker object wants to call
-// WorkerReportingProxy, this class will convert to Chrome data types first and
-// then call the supplied WebCommonWorkerClient.
-class WebSharedWorkerImpl final : public WorkerReportingProxy,
-                                  public WebFrameClient,
+// implementation. This is basically accessed on the main thread, but some
+// methods must be called from a worker thread. Such methods are suffixed with
+// *OnWorkerThread or have header comments.
+class WebSharedWorkerImpl final : public WebFrameClient,
                                   public WebSharedWorker,
                                   public WebDevToolsAgentClient,
                                   private WorkerLoaderProxyProvider {
  public:
   explicit WebSharedWorkerImpl(WebSharedWorkerClient*);
 
-  // WorkerReportingProxy methods:
-  void countFeature(UseCounter::Feature) override;
-  void countDeprecation(UseCounter::Feature) override;
-  void reportException(const WTF::String&,
-                       std::unique_ptr<SourceLocation>,
-                       int exceptionId) override;
-  void reportConsoleMessage(MessageSource,
-                            MessageLevel,
-                            const String& message,
-                            SourceLocation*) override;
-  void postMessageToPageInspector(const WTF::String&) override;
-  void didEvaluateWorkerScript(bool success) override {}
-  void didCloseWorkerGlobalScope() override;
-  void willDestroyWorkerGlobalScope() override {}
-  void didTerminateWorkerThread() override;
-
   // WebFrameClient methods to support resource loading thru the 'shadow page'.
   WebApplicationCacheHost* createApplicationCacheHost(
       WebApplicationCacheHostClient*) override;
   void willSendRequest(WebLocalFrame*, WebURLRequest&) override;
   void didFinishDocumentLoad(WebLocalFrame*) override;
   bool isControlledByServiceWorker(WebDataSource&) override;
   int64_t serviceWorkerID(WebDataSource&) override;
 
   // WebDevToolsAgentClient overrides.
   void sendProtocolMessage(int sessionId,
@@ skipping 17 matching lines @@
   void attachDevTools(const WebString& hostId, int sessionId) override;
   void reattachDevTools(const WebString& hostId,
                         int sesionId,
                         const WebString& savedState) override;
   void detachDevTools() override;
   void dispatchDevToolsMessage(int sessionId,
                                int callId,
                                const WebString& method,
                                const WebString& message) override;
 
+  // Callback methods for WebSharedWorkerReportingProxyImpl.
+  void countFeature(UseCounter::Feature);
+  void postMessageToPageInspector(const String& message);
+  void didCloseWorkerGlobalScope();
+  void didTerminateWorkerThread();
+
  private:
   ~WebSharedWorkerImpl() override;
 
   WorkerThread* workerThread() { return m_workerThread.get(); }
 
   // Shuts down the worker thread.
   void terminateWorkerThread();
 
   // Creates the shadow loader used for worker network requests.
   void initializeLoader();
 
   void loadShadowPage();
   void didReceiveScriptLoaderResponse();
   void onScriptLoaderFinished();
 
-  void connectTask(WebMessagePortChannelUniquePtr);
-
-  // Tasks that are run on the main thread.
-  void didCloseWorkerGlobalScopeOnMainThread();
-  void didTerminateWorkerThreadOnMainThread();
-
-  void postMessageToPageInspectorOnMainThread(const String& message);
+  void connectTaskOnWorkerThread(WebMessagePortChannelUniquePtr);
 
   // WorkerLoaderProxyProvider
+  // postTaskToLoader() must be called from a worker thread.
   void postTaskToLoader(const WebTraceLocation&,
                         std::unique_ptr<WTF::CrossThreadClosure>) override;
   void postTaskToWorkerGlobalScope(
       const WebTraceLocation&,
       std::unique_ptr<WTF::CrossThreadClosure>) override;
   ExecutionContext* getLoaderExecutionContext() override;
 
   // 'shadow page' - created to proxy loading requests from the worker.
   // Will be accessed by worker thread when posting tasks.
   Persistent<ExecutionContext> m_loadingDocument;
   WebView* m_webView;
   Persistent<WebLocalFrameImpl> m_mainFrame;
   bool m_askedToTerminate;
 
-  // This one is bound to and used only on the main thread.
   std::unique_ptr<WebServiceWorkerNetworkProvider> m_networkProvider;
 
   Persistent<WorkerInspectorProxy> m_workerInspectorProxy;
 
   // Owned by the main thread, but will be accessed by the worker.
   CrossThreadPersistent<ParentFrameTaskRunners> m_parentFrameTaskRunners;
 
+  Persistent<WebSharedWorkerReportingProxyImpl> m_reportingProxy;
   std::unique_ptr<WorkerThread> m_workerThread;
 
   WebSharedWorkerClient* m_client;
 
   bool m_pauseWorkerContextOnStart;
   bool m_isPausedOnStart;
 
   // Kept around only while main script loading is ongoing.
   RefPtr<WorkerScriptLoader> m_mainScriptLoader;
 
   RefPtr<WorkerLoaderProxy> m_loaderProxy;
 
   WebURL m_url;
   WebString m_name;
   WebAddressSpace m_creationAddressSpace;
 };
 
 }  // namespace blink
 
 #endif  // WebSharedWorkerImpl_h