Implement SharedWorkerServiceImpl::CreateWorker and SharedWorkerInstance and SharedWorkerHost

content/browser/shared_worker/shared_worker_service_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
 
+#include "content/browser/shared_worker/shared_worker_host.h"
+#include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
+#include "content/browser/worker_host/worker_document_set.h"
+#include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/worker_service_observer.h"
 
 namespace content {
 
 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return Singleton<SharedWorkerServiceImpl>::get();
 }
@@ skipping 25 matching lines @@
   observers_.RemoveObserver(observer);
 }
 
 void SharedWorkerServiceImpl::CreateWorker(
     const ViewHostMsg_CreateWorker_Params& params,
     int route_id,
     SharedWorkerMessageFilter* filter,
     ResourceContext* resource_context,
     const WorkerStoragePartition& partition,
     bool* url_mismatch) {
-  // TODO(horo): implement this.
-  NOTIMPLEMENTED();
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  *url_mismatch = false;
+  SharedWorkerInstance* existing_instance =
+      FindSharedWorkerInstance(
+          params.url, params.name, partition, resource_context);
+  if (existing_instance) {
+    if (params.url != existing_instance->url()) {
+      *url_mismatch = true;
+      return;
+    }
+    if (existing_instance->load_failed()) {
+      filter->Send(new ViewMsg_WorkerScriptLoadFailed(route_id));
+      return;
+    }
+    existing_instance->AddFilter(filter, route_id);
+    existing_instance->worker_document_set()->Add(
+        filter, params.document_id, filter->render_process_id(),
+        params.render_frame_route_id);
+    filter->Send(new ViewMsg_WorkerCreated(route_id));
+    return;
+  }
+
+  scoped_ptr<SharedWorkerInstance> instance(new SharedWorkerInstance(
+      params.url,
+      params.name,
+      params.content_security_policy,
+      params.security_policy_type,
+      resource_context,
+      partition));
+  instance->AddFilter(filter, route_id);
+  instance->worker_document_set()->Add(
+      filter, params.document_id, filter->render_process_id(),
+      params.render_frame_route_id);
+
+  SharedWorkerHost *worker(new SharedWorkerHost(instance.release()));

[kinuko, 2014/02/26 08:51:17]

nit: can we create this as scoped_ptr<SharedWorkerHost> and then release on line
94?

[horo, 2014/02/26 10:36:19]

Done.

+  worker->Init(filter);

[kinuko, 2014/02/26 08:51:17]

We don't need to check the return value of Init() here?

[horo, 2014/02/26 10:36:19]

I changed the return value type of SharedWorkerHost::Init() to void.

+  // |worker_hosts_| owns |worker|.
+  worker_hosts_.push_back(worker);
+  FOR_EACH_OBSERVER(
+      WorkerServiceObserver, observers_,
+      WorkerCreated(worker->instance()->url(),
+                    worker->instance()->name(),
+                    filter->render_process_id(),
+                    worker->worker_route_id()));
 }
 
 void SharedWorkerServiceImpl::ForwardToWorker(
     const IPC::Message& message,
     SharedWorkerMessageFilter* filter) {
   // TODO(horo): implement this.
   NOTIMPLEMENTED();
 }
 
 void SharedWorkerServiceImpl::DocumentDetached(
@@ skipping 69 matching lines @@
   // TODO(horo): implement this.
   NOTIMPLEMENTED();
 }
 
 void SharedWorkerServiceImpl::OnSharedWorkerMessageFilterClosing(
     SharedWorkerMessageFilter* filter) {
   // TODO(horo): implement this.
   NOTIMPLEMENTED();
 }
 
+SharedWorkerInstance* SharedWorkerServiceImpl::FindSharedWorkerInstance(
+    const GURL& url,
+    const base::string16& name,
+    const WorkerStoragePartition& partition,
+    ResourceContext* resource_context) {
+  for (ScopedVector<SharedWorkerHost>::const_iterator iter =
+           worker_hosts_.begin();
+       iter != worker_hosts_.end();
+       ++iter) {
+    SharedWorkerInstance* instance = (*iter)->instance();
+    if (instance &&
+        instance->Matches(url, name, partition, resource_context))
+      return instance;
+  }
+  return NULL;
+}
+
 }  // namespace content