Split blink::WebSharedWorker interface into two in blink side (phase:1/3)

This is one of cleanup patches.

Goal:
Split blink::WebSharedWorker interface into two interfaces(WebSharedWorker, WebSharedWorkerConnector)
WebSharedWorkerConnector will be used in parent-context side.
WebSharedWorker will be used in worker-context side


Phase 1: in blink (this patch)
- Introduce blink::WebSharedWorkerConnector
- Make blink::WebSharedWorker to be a subclass of blink::WebSharedWorkerConnector
- Move isStarted(), startWorkerContext() and ConnectListener and connect() from blink::WebSharedWorker to blink::WebSharedWorkerConnector.
- Set default value of connect()'s 2nd argument(ConnectListener) to 0.
- Add blink:WebSharedWorkerRepositoryClient::createSharedWorkerConnector() which calls createSharedWorker()

Phase 2: in Chrome
- Change content::WebSharedWorkerProxy to be a subclass of blink::WebSharedWorkerConnector, which is currently a subclass of blink::WebSharedWorker.
- Remove content::WebSharedWorkerProxy::terminateWorkerContext() and content::WebSharedWorkerProxy::clientDestroyed().
- Remove "WebSharedWorker* SharedWorkerRepository::createSharedWorker()"
- Introduce "WebSharedWorkerConnector* SharedWorkerRepository::createSharedWorkerConnector()"

Phase 3: in blink
- Make blink::WebSharedWorker independent from blink::WebSharedWorkerConnector.
- Remove blink::WebSharedWorkerImpl::isStarted()
- Add startWorkerContext() and connect() to blink::WebSharedWorker.
- Remove blink:WebSharedWorkerRepositoryClient::createSharedWorker()
- Remove default value of blink::WebSharedWorkerConnector::connect()'s 2nd argument.


BUG=327600

Review URL: https://codereview.chromium.org/104943005

git-svn-id: svn://svn.chromium.org/blink/trunk@163707 bbb929c8-8fbe-4397-9dbb-9b2b20218538

5 files changed, 98 insertions, 38 deletions

diff --git a/third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.cpp b/third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.cpp
index db26874..a519ea9 100644
--- a/third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.cpp
+++ b/third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.cpp
@@ -58,13 +58,13 @@ using namespace WebCore;
 namespace blink {
 
 // Callback class that keeps the SharedWorker and WebSharedWorker objects alive while loads are potentially happening, and also translates load errors into error events on the worker.
-class SharedWorkerScriptLoader : private WorkerScriptLoaderClient, private WebSharedWorker::ConnectListener {
+class SharedWorkerScriptLoader : private WorkerScriptLoaderClient, private WebSharedWorkerConnector::ConnectListener {
 public:
-    SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, const KURL& url, const String& name, PassOwnPtr<WebMessagePortChannel> channel, PassOwnPtr<WebSharedWorker> webWorker)
+    SharedWorkerScriptLoader(PassRefPtr<SharedWorker> worker, const KURL& url, const String& name, PassOwnPtr<WebMessagePortChannel> channel, PassOwnPtr<WebSharedWorkerConnector> webWorkerConnector)
         : m_worker(worker)
         , m_url(url)
         , m_name(name)
-        , m_webWorker(webWorker)
+        , m_webWorkerConnector(webWorkerConnector)
         , m_channel(channel)
         , m_scriptLoader(WorkerScriptLoader::create())
         , m_loading(false)
@@ -87,7 +87,7 @@ private:
     RefPtr<SharedWorker> m_worker;
     KURL m_url;
     String m_name;
-    OwnPtr<WebSharedWorker> m_webWorker;
+    OwnPtr<WebSharedWorkerConnector> m_webWorkerConnector;
     OwnPtr<WebMessagePortChannel> m_channel;
     RefPtr<WorkerScriptLoader> m_scriptLoader;
     bool m_loading;
@@ -104,7 +104,7 @@ void SharedWorkerScriptLoader::load()
 {
     ASSERT(!m_loading);
     // If the shared worker is not yet running, load the script resource for it, otherwise just send it a connect event.
-    if (m_webWorker->isStarted()) {
+    if (m_webWorkerConnector->isStarted()) {
         sendConnect();
     } else {
         // Keep the worker + JS wrapper alive until the resource load is complete in case we need to dispatch an error event.
@@ -129,7 +129,7 @@ void SharedWorkerScriptLoader::notifyFinished()
     } else {
         InspectorInstrumentation::scriptImported(m_worker->executionContext(), m_scriptLoader->identifier(), m_scriptLoader->script());
         // Pass the script off to the worker, then send a connect event.
-        m_webWorker->startWorkerContext(m_url, m_name, m_worker->executionContext()->userAgent(m_url), m_scriptLoader->script(), m_worker->executionContext()->contentSecurityPolicy()->deprecatedHeader(), static_cast<blink::WebContentSecurityPolicyType>(m_worker->executionContext()->contentSecurityPolicy()->deprecatedHeaderType()), m_responseAppCacheID);
+        m_webWorkerConnector->startWorkerContext(m_url, m_name, m_worker->executionContext()->userAgent(m_url), m_scriptLoader->script(), m_worker->executionContext()->contentSecurityPolicy()->deprecatedHeader(), static_cast<blink::WebContentSecurityPolicyType>(m_worker->executionContext()->contentSecurityPolicy()->deprecatedHeaderType()), m_responseAppCacheID);
         sendConnect();
     }
 }
@@ -137,7 +137,7 @@ void SharedWorkerScriptLoader::notifyFinished()
 void SharedWorkerScriptLoader::sendConnect()
 {
     // Send the connect event off, and linger until it is done sending.
-    m_webWorker->connect(m_channel.leakPtr(), this);
+    m_webWorkerConnector->connect(m_channel.leakPtr(), this);
 }
 
 void SharedWorkerScriptLoader::connected()
@@ -159,8 +159,8 @@ void SharedWorkerRepositoryClientImpl::connect(PassRefPtr<SharedWorker> worker,
     // No nested workers (for now) - connect() should only be called from document context.
     ASSERT(worker->executionContext()->isDocument());
     Document* document = toDocument(worker->executionContext());
-    OwnPtr<WebSharedWorker> webWorker = adoptPtr(m_client->createSharedWorker(url, name, getId(document)));
-    if (!webWorker) {
+    OwnPtr<WebSharedWorkerConnector> webWorkerConnector = adoptPtr(m_client->createSharedWorkerConnector(url, name, getId(document)));
+    if (!webWorkerConnector) {
         // Existing worker does not match this url, so return an error back to the caller.
         exceptionState.throwDOMException(URLMismatchError, "The location of the SharedWorker named '" + name + "' does not exactly match the provided URL ('" + url.elidedString() + "').");
         return;
@@ -168,7 +168,7 @@ void SharedWorkerRepositoryClientImpl::connect(PassRefPtr<SharedWorker> worker,
 
     // The loader object manages its own lifecycle (and the lifecycles of the two worker objects).
     // It will free itself once loading is completed.
-    SharedWorkerScriptLoader* loader = new SharedWorkerScriptLoader(worker, url, name, port, webWorker.release());
+    SharedWorkerScriptLoader* loader = new SharedWorkerScriptLoader(worker, url, name, port, webWorkerConnector.release());
     loader->load();
 }
 
diff --git a/third_party/WebKit/Source/web/WebSharedWorkerImpl.h b/third_party/WebKit/Source/web/WebSharedWorkerImpl.h
index 98b608c..f236b49 100644
--- a/third_party/WebKit/Source/web/WebSharedWorkerImpl.h
+++ b/third_party/WebKit/Source/web/WebSharedWorkerImpl.h
@@ -88,13 +88,12 @@ public:
     virtual void didCreateDataSource(WebFrame*, WebDataSource*);
     virtual WebApplicationCacheHost* createApplicationCacheHost(WebFrame*, WebApplicationCacheHostClient*);
 
-
-    // WebSharedWorker methods:
+    // WebSharedWorkerConnector methods:
     virtual bool isStarted();
-
     virtual void startWorkerContext(const WebURL&, const WebString& name, const WebString& userAgent, const WebString& sourceCode, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType, long long cacheId);
-
     virtual void connect(WebMessagePortChannel*, ConnectListener*);
+
+    // WebSharedWorker methods:
     virtual void terminateWorkerContext();
     virtual void clientDestroyed();
 
diff --git a/third_party/WebKit/public/web/WebSharedWorker.h b/third_party/WebKit/public/web/WebSharedWorker.h
index 3983d46..377a8fa 100644
--- a/third_party/WebKit/public/web/WebSharedWorker.h
+++ b/third_party/WebKit/public/web/WebSharedWorker.h
@@ -33,6 +33,7 @@
 
 #include "../platform/WebCommon.h"
 #include "WebContentSecurityPolicy.h"
+#include "WebSharedWorkerConnector.h"
 
 namespace WebCore {
 class ScriptExecutionContext;
@@ -46,35 +47,14 @@ class WebSharedWorkerClient;
 class WebURL;
 
 // This is the interface to a SharedWorker thread.
-// Since SharedWorkers communicate entirely through MessagePorts this interface only contains APIs for starting up a SharedWorker.
-class WebSharedWorker {
+// FIXME(horo): Make WebSharedWorker independent from WebSharedWorkerConnector.
+class WebSharedWorker : public WebSharedWorkerConnector {
 public:
     // Invoked from the worker thread to instantiate a WebSharedWorker that interacts with the WebKit worker components.
     BLINK_EXPORT static WebSharedWorker* create(WebSharedWorkerClient*);
 
     virtual ~WebSharedWorker() {};
 
-    // Returns false if the thread hasn't been started yet (script loading has not taken place).
-    // FIXME(atwilson): Remove this when we move the initial script loading into the worker process.
-    virtual bool isStarted() = 0;
-
-    virtual void startWorkerContext(const WebURL& scriptURL,
-                                    const WebString& name,
-                                    const WebString& userAgent,
-                                    const WebString& sourceCode,
-                                    const WebString& contentSecurityPolicy,
-                                    WebContentSecurityPolicyType,
-                                    long long scriptResourceAppCacheID) = 0;
-
-    class ConnectListener {
-    public:
-        // Invoked once the connect event has been sent so the caller can free this object.
-        virtual void connected() = 0;
-    };
-
-    // Sends a connect event to the SharedWorker context. The listener is invoked when this async operation completes.
-    virtual void connect(WebMessagePortChannel*, ConnectListener*) = 0;
-
     // Invoked to shutdown the worker when there are no more associated documents.
     virtual void terminateWorkerContext() = 0;
 
diff --git a/third_party/WebKit/public/web/WebSharedWorkerConnector.h b/third_party/WebKit/public/web/WebSharedWorkerConnector.h
new file mode 100644
index 0000000..8e1d2d6
--- /dev/null
+++ b/third_party/WebKit/public/web/WebSharedWorkerConnector.h
@@ -0,0 +1,73 @@
+/*
+ * 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
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * 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 WebSharedWorkerConnector_h
+#define WebSharedWorkerConnector_h
+
+#include "WebContentSecurityPolicy.h"
+
+namespace blink {
+
+class WebString;
+class WebMessagePortChannel;
+class WebURL;
+
+// This is the interface to conncect to SharedWorker.
+// Since SharedWorkers communicate entirely through MessagePorts this interface only contains APIs for starting up a SharedWorker.
+class WebSharedWorkerConnector {
+public:
+    virtual ~WebSharedWorkerConnector() { }
+
+    // Returns false if the thread hasn't been started yet (script loading has not taken place).
+    // FIXME(atwilson): Remove this when we move the initial script loading into the worker process.
+    virtual bool isStarted() = 0;
+
+    virtual void startWorkerContext(
+        const WebURL& scriptURL,
+        const WebString& name,
+        const WebString& userAgent,
+        const WebString& sourceCode,
+        const WebString& contentSecurityPolicy,
+        WebContentSecurityPolicyType,
+        long long scriptResourceAppCacheID) = 0;
+
+    class ConnectListener {
+    public:
+        // Invoked once the connect event has been sent so the caller can free this object.
+        virtual void connected() = 0;
+    };
+
+    // Sends a connect event to the SharedWorker context. The listener is invoked when this async operation completes.
+    virtual void connect(WebMessagePortChannel*, ConnectListener* = 0) = 0;
+};
+
+} // namespace blink
+
+#endif
diff --git a/third_party/WebKit/public/web/WebSharedWorkerRepositoryClient.h b/third_party/WebKit/public/web/WebSharedWorkerRepositoryClient.h
index e961a73..97129a3 100644
--- a/third_party/WebKit/public/web/WebSharedWorkerRepositoryClient.h
+++ b/third_party/WebKit/public/web/WebSharedWorkerRepositoryClient.h
@@ -31,10 +31,11 @@
 #ifndef WebSharedWorkerRepositoryClient_h
 #define WebSharedWorkerRepositoryClient_h
 
+#include "WebSharedWorker.h"
+
 namespace blink {
 
 class WebString;
-class WebSharedWorker;
 class WebURL;
 
 class WebSharedWorkerRepositoryClient {
@@ -43,8 +44,15 @@ public:
     typedef unsigned long long DocumentID;
 
     // Creates a new shared worker. This may return null.
+    // FIXME(horo):Remove this method.
     virtual WebSharedWorker* createSharedWorker(const WebURL&, const WebString&, DocumentID) { return 0; }
 
+    // Creates a new shared worker connector. This may return null.
+    virtual WebSharedWorkerConnector* createSharedWorkerConnector(const WebURL& url, const WebString& name, DocumentID id)
+    {
+        return createSharedWorker(url, name, id);
+    }
+
     // Invoked when a document has been detached. DocumentID can be re-used after documentDetached() is invoked.
     virtual void documentDetached(DocumentID) { }
 };