Removing dedicated worker-related IPC codei (first round).

content/browser/worker_host/worker_process_host.cc

 // Copyright (c) 2011 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/worker_host/worker_process_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/base_switches.h"
@@ skipping 263 matching lines @@
 }
 
 void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
   ChildProcessSecurityPolicy::GetInstance()->GrantRequestURL(
       id(), instance.url());
 
   instances_.push_back(instance);
 
   WorkerProcessMsg_CreateWorker_Params params;
   params.url = instance.url();
-  params.is_shared = instance.shared();
   params.name = instance.name();
   params.route_id = instance.worker_route_id();
   params.creator_process_id = instance.parent_process_id();
-  params.creator_appcache_host_id = instance.parent_appcache_host_id();
   params.shared_worker_appcache_id = instance.main_resource_appcache_id();
   Send(new WorkerProcessMsg_CreateWorker(params));
 
   UpdateTitle();
 
   // Walk all pending filters and let them know the worker has been created
   // (could be more than one in the case where we had to queue up worker
   // creation because the worker process limit was reached).
   for (WorkerInstance::FilterList::const_iterator i =
            instance.filters().begin();
@@ skipping 37 matching lines @@
   if (handled)
     return true;
 
   if (message.type() == WorkerHostMsg_WorkerContextDestroyed::ID) {
     WorkerService::GetInstance()->NotifyWorkerDestroyed(this,
                                                         message.routing_id());
   }
 
   for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
     if (i->worker_route_id() == message.routing_id()) {
-      if (!i->shared()) {
-        // Don't relay messages from shared workers (all communication is via
-        // the message port).
-        WorkerInstance::FilterInfo info = i->GetFilter();
-        RelayMessage(message, info.first, info.second);
-      }
-
       if (message.type() == WorkerHostMsg_WorkerContextDestroyed::ID) {
         instances_.erase(i);
         UpdateTitle();
       }
       return true;
     }
   }
   return false;
 }
 
@@ skipping 85 matching lines @@
     if (message.type() == WorkerMsg_StartWorkerContext::ID)
       WorkerService::GetInstance()->NotifyWorkerContextStarted(this, route_id);
     return;
   }
 }
 
 void WorkerProcessHost::FilterShutdown(WorkerMessageFilter* filter) {
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
     bool shutdown = false;
     i->RemoveFilters(filter);
-    if (i->shared()) {
-      i->worker_document_set()->RemoveAll(filter);
-      if (i->worker_document_set()->IsEmpty()) {
-        shutdown = true;
-      }
-    } else if (i->NumFilters() == 0) {
+
+    i->worker_document_set()->RemoveAll(filter);
+    if (i->worker_document_set()->IsEmpty()) {
       shutdown = true;
     }
     if (shutdown) {
       Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
       i = instances_.erase(i);
     } else {
       ++i;
     }
   }
 }
@@ skipping 32 matching lines @@
     display_title += *i;
   }
 
   set_name(ASCIIToUTF16(display_title));
 }
 
 void WorkerProcessHost::DocumentDetached(WorkerMessageFilter* filter,
                                          unsigned long long document_id) {
   // Walk all instances and remove the document from their document set.
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
-    if (!i->shared()) {
+    i->worker_document_set()->Remove(filter, document_id);
+    if (i->worker_document_set()->IsEmpty()) {
+      // This worker has no more associated documents - shut it down.
+      Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
+      i = instances_.erase(i);
+    } else {
       ++i;
-    } else {
-      i->worker_document_set()->Remove(filter, document_id);
-      if (i->worker_document_set()->IsEmpty()) {
-        // This worker has no more associated documents - shut it down.
-        Send(new WorkerMsg_TerminateWorkerContext(i->worker_route_id()));
-        i = instances_.erase(i);
-      } else {
-        ++i;
-      }
     }
   }
 }
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
-    bool shared,
     const string16& name,
     int worker_route_id,
     int parent_process_id,
-    int parent_appcache_host_id,
     int64 main_resource_appcache_id,
     const content::ResourceContext* resource_context)
     : url_(url),
-      shared_(shared),
       closed_(false),
       name_(name),
       worker_route_id_(worker_route_id),
       parent_process_id_(parent_process_id),
-      parent_appcache_host_id_(parent_appcache_host_id),
       main_resource_appcache_id_(main_resource_appcache_id),
       worker_document_set_(new WorkerDocumentSet()),
       resource_context_(resource_context) {
   DCHECK(resource_context_);
 }
 
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
     bool shared,
     const string16& name,
     const content::ResourceContext* resource_context)
     : url_(url),
-      shared_(shared),
       closed_(false),
       name_(name),
       worker_route_id_(MSG_ROUTING_NONE),
       parent_process_id_(0),
-      parent_appcache_host_id_(0),
       main_resource_appcache_id_(0),
       worker_document_set_(new WorkerDocumentSet()),
       resource_context_(resource_context) {
   DCHECK(resource_context_);
 }
 
 WorkerProcessHost::WorkerInstance::~WorkerInstance() {
 }
 
 // Compares an instance based on the algorithm in the WebWorkers spec - an
 // instance matches if the origins of the URLs match, and:
 // a) the names are non-empty and equal
 // -or-
 // b) the names are both empty, and the urls are equal
 bool WorkerProcessHost::WorkerInstance::Matches(
     const GURL& match_url,
     const string16& match_name,
     const content::ResourceContext* resource_context) const {
   // Only match open shared workers.
-  if (!shared_ || closed_)
+  if (closed_)
     return false;
 
   // Have to match the same ResourceContext.
   if (resource_context_ != resource_context)
     return false;
 
   if (url_.GetOrigin() != match_url.GetOrigin())
     return false;
 
   if (name_.empty() && match_name.empty())
     return url_ == match_url;
 
   return name_ == match_name;
 }
 
 void WorkerProcessHost::WorkerInstance::AddFilter(WorkerMessageFilter* filter,
                                                   int route_id) {
   if (!HasFilter(filter, route_id)) {
     FilterInfo info(filter, route_id);
     filters_.push_back(info);
   }
-  // Only shared workers can have more than one associated filter.
-  DCHECK(shared_ || filters_.size() == 1);
 }
 
 void WorkerProcessHost::WorkerInstance::RemoveFilter(
     WorkerMessageFilter* filter, int route_id) {
   for (FilterList::iterator i = filters_.begin(); i != filters_.end();) {
     if (i->first == filter && i->second == route_id)
       i = filters_.erase(i);
     else
       ++i;
   }
@@ skipping 34 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }