SharedWorker: Make shared workers keyed by a pair of url and name

third_party/WebKit/Source/web/SharedWorkerRepositoryClientImpl.cpp

 /*
  * 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 12 matching lines @@
  * 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.
  */
 
 #include "web/SharedWorkerRepositoryClientImpl.h"
 
-#include "bindings/core/v8/ExceptionMessages.h"
-#include "bindings/core/v8/ExceptionState.h"
-#include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/events/Event.h"
 #include "core/frame/UseCounter.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/workers/SharedWorker.h"
 #include "platform/network/ResourceResponse.h"
 #include "public/platform/WebMessagePortChannel.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
@@ skipping 61 matching lines @@
 static WebSharedWorkerRepositoryClient::DocumentID getId(void* document) {
   DCHECK(document);
   return reinterpret_cast<WebSharedWorkerRepositoryClient::DocumentID>(
       document);
 }
 
 void SharedWorkerRepositoryClientImpl::connect(
     SharedWorker* worker,
     WebMessagePortChannelUniquePtr port,
     const KURL& url,
-    const String& name,
-    ExceptionState& exceptionState) {
+    const String& name) {
   DCHECK(m_client);
 
   // No nested workers (for now) - connect() should only be called from document
   // context.
   DCHECK(worker->getExecutionContext()->isDocument());
   Document* document = toDocument(worker->getExecutionContext());
 
   // TODO(estark): this is broken, as it only uses the first header
   // when multiple might have been sent. Fix by making the
   // SharedWorkerConnector interface take a map that can contain
@@ skipping 15 matching lines @@
       m_client->createSharedWorkerConnector(
           url, name, getId(document), header, headerType,
           worker->getExecutionContext()->securityContext().addressSpace(),
           isSecureContext ? WebSharedWorkerCreationContextTypeSecure
                           : WebSharedWorkerCreationContextTypeNonsecure,
           &creationError);
 
   switch (creationError) {
     case WebWorkerCreationErrorNone:
       break;
-    case WebWorkerCreationErrorURLMismatch:
-      // 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;
     case WebWorkerCreationErrorSecureContextMismatch:
       UseCounter::Feature feature =
           isSecureContext
               ? UseCounter::NonSecureSharedWorkerAccessedFromSecureContext
               : UseCounter::SecureSharedWorkerAccessedFromNonSecureContext;
       UseCounter::count(document, feature);
       break;
   }
 
   // The connector object manages its own lifecycle (and the lifecycles of the
   // two worker objects).  It will free itself once connecting is completed.
   SharedWorkerConnector* connector = new SharedWorkerConnector(
       worker, std::move(port), std::move(webWorkerConnector));
   connector->connect();
 }
 
 void SharedWorkerRepositoryClientImpl::documentDetached(Document* document) {
   DCHECK(m_client);
   m_client->documentDetached(getId(document));
 }
 
 SharedWorkerRepositoryClientImpl::SharedWorkerRepositoryClientImpl(
     WebSharedWorkerRepositoryClient* client)
     : m_client(client) {}
 
 }  // namespace blink