Refactor SharedWorkerHost and SharedWorkerInstance.

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 <algorithm>
 #include <iterator>
 #include <set>
 #include <vector>
@@ skipping 111 matching lines @@
 void SharedWorkerServiceImpl::CreateWorker(
     const ViewHostMsg_CreateWorker_Params& params,
     int route_id,
     SharedWorkerMessageFilter* filter,
     ResourceContext* resource_context,
     const WorkerStoragePartition& partition,
     bool* url_mismatch) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   ScopedWorkerDependencyChecker checker(this);
   *url_mismatch = false;
-  SharedWorkerInstance* existing_instance =
-      FindSharedWorkerInstance(
-          params.url, params.name, partition, resource_context);
-  if (existing_instance) {
-    if (params.url != existing_instance->url()) {
+  SharedWorkerHost* existing_host = FindSharedWorkerHost(
+      params.url, params.name, partition, resource_context);
+  if (existing_host) {
+    if (params.url != existing_host->instance()->url()) {
       *url_mismatch = true;
       return;
     }
-    if (existing_instance->load_failed()) {
+    if (existing_host->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);
+    existing_host->AddFilter(filter, route_id);
+    existing_host->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);
+  scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost(instance.release()));
+  host->AddFilter(filter, route_id);
+  host->worker_document_set()->Add(filter,
+                                   params.document_id,
+                                   filter->render_process_id(),
+                                   params.render_frame_route_id);
 
-  scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost(instance.release()));
   host->Init(filter);
   const int worker_route_id = host->worker_route_id();
   worker_hosts_.set(std::make_pair(filter->render_process_id(),
                                    worker_route_id),
                     host.Pass());
 
   FOR_EACH_OBSERVER(
       WorkerServiceObserver, observers_,
       WorkerCreated(params.url,
                     params.name,
@@ skipping 116 matching lines @@
     worker_hosts_.erase(remove_list[i]);
 }
 
 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
     SharedWorkerMessageFilter* filter,
     int worker_route_id) {
   return worker_hosts_.get(std::make_pair(filter->render_process_id(),
                                           worker_route_id));
 }
 
-SharedWorkerInstance* SharedWorkerServiceImpl::FindSharedWorkerInstance(
+SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
     const GURL& url,
     const base::string16& name,
     const WorkerStoragePartition& partition,
     ResourceContext* resource_context) {
   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
     SharedWorkerInstance* instance = iter->second->instance();
-    if (instance && instance->Matches(url, name, partition, resource_context))
-      return instance;
+    if (instance && !iter->second->closed() &&
+        instance->Matches(url, name, partition, resource_context))
+      return iter->second;
   }
   return NULL;
 }
 
 const std::set<int>
 SharedWorkerServiceImpl::GetRenderersWithWorkerDependency() {
   std::set<int> dependent_renderers;
   for (WorkerHostMap::iterator host_iter = worker_hosts_.begin();
        host_iter != worker_hosts_.end();
        ++host_iter) {
     const int process_id = host_iter->first.first;
     if (dependent_renderers.count(process_id))
       continue;
-    SharedWorkerInstance* instance = host_iter->second->instance();
-    if (instance &&
-        instance->worker_document_set()->ContainsExternalRenderer(process_id)) {
+    if (host_iter->second->instance() &&
+        host_iter->second->worker_document_set()->ContainsExternalRenderer(
+            process_id)) {
       dependent_renderers.insert(process_id);
     }
   }
   return dependent_renderers;
 }
 
 void SharedWorkerServiceImpl::CheckWorkerDependency() {
   const std::set<int> current_worker_depended_renderers =
       GetRenderersWithWorkerDependency();
   std::vector<int> added_items;
@@ skipping 13 matching lines @@
     update_worker_dependency_(added_items, removed_items);
   }
 }
 
 void SharedWorkerServiceImpl::ChangeUpdateWorkerDependencyFuncForTesting(
     UpdateWorkerDependencyFunc new_func) {
   update_worker_dependency_ = new_func;
 }
 
 }  // namespace content