Remove flags for Workers that violate multiple profile and storage isolation assumptions.

content/browser/worker_host/worker_service_impl.cc

 // Copyright (c) 2012 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_service_impl.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
-#include "base/sys_info.h"
 #include "base/threading/thread.h"
 #include "content/browser/debugger/worker_devtools_manager.h"
 #include "content/browser/worker_host/worker_message_filter.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
-#include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 
 namespace content {
 
-const int WorkerServiceImpl::kMaxWorkerProcessesWhenSharing = 10;
 const int WorkerServiceImpl::kMaxWorkersWhenSeparate = 64;
 const int WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate = 16;
 
 WorkerService* WorkerService::GetInstance() {
   return WorkerServiceImpl::GetInstance();
 }
 
 WorkerServiceImpl* WorkerServiceImpl::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return Singleton<WorkerServiceImpl>::get();
@@ skipping 168 matching lines @@
     if (iter->worker_document_set()->IsEmpty()) {
       iter = pending_shared_workers_.erase(iter);
     } else {
       ++iter;
     }
   }
 }
 
 bool WorkerServiceImpl::CreateWorkerFromInstance(
     WorkerProcessHost::WorkerInstance instance) {
-  // TODO(michaeln): We need to ensure that a process is working
-  // on behalf of a single browser context. The process sharing logic below
-  // does not ensure that. Consider making WorkerService a per browser context
-  // object to help with this.
-  WorkerProcessHost* worker = NULL;
-  if (CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kWebWorkerProcessPerCore)) {
-    worker = GetProcessToFillUpCores();
-  } else if (CommandLine::ForCurrentProcess()->HasSwitch(
-                 switches::kWebWorkerShareProcesses)) {
-    worker = GetProcessForDomain(instance.url());
-  } else {  // One process per worker.
-    if (!CanCreateWorkerProcess(instance)) {
-      queued_workers_.push_back(instance);
-      return true;
-    }
+  if (!CanCreateWorkerProcess(instance)) {
+    queued_workers_.push_back(instance);
+    return true;
   }
 
   // Check to see if this shared worker is already running (two pages may have
   // tried to start up the worker simultaneously).
   // See if a worker with this name already exists.
   WorkerProcessHost::WorkerInstance* existing_instance =
       FindSharedWorkerInstance(
           instance.url(), instance.name(), instance.partition(),
           instance.resource_context());
   WorkerProcessHost::WorkerInstance::FilterInfo filter_info =
@@ skipping 46 matching lines @@
       DCHECK(iter->NumFilters() == 1);
       WorkerProcessHost::WorkerInstance::FilterInfo filter_info =
           iter->GetFilter();
       instance.AddFilter(filter_info.first, filter_info.second);
       iter = queued_workers_.erase(iter);
     } else {
       ++iter;
     }
   }
 
-  if (!worker) {
-    WorkerMessageFilter* first_filter = instance.filters().begin()->first;
-    worker = new WorkerProcessHost(instance.resource_context(),
-                                   instance.partition());
-    // TODO(atwilson): This won't work if the message is from a worker process.
-    // We don't support that yet though (this message is only sent from
-    // renderers) but when we do, we'll need to add code to pass in the current
-    // worker's document set for nested workers.
-    if (!worker->Init(first_filter->render_process_id())) {
-      delete worker;
-      return false;
-    }
+  WorkerMessageFilter* first_filter = instance.filters().begin()->first;
+  WorkerProcessHost* worker = new WorkerProcessHost(
+      instance.resource_context(), instance.partition());
+  // TODO(atwilson): This won't work if the message is from a worker process.
+  // We don't support that yet though (this message is only sent from
+  // renderers) but when we do, we'll need to add code to pass in the current
+  // worker's document set for nested workers.
+  if (!worker->Init(first_filter->render_process_id())) {
+    delete worker;
+    return false;
   }
 
-  // TODO(michaeln): As written, test can fail per my earlier comment in
-  // this method, but that's a bug.
-  // DCHECK(worker->request_context() == instance.GetRequestContext());
-
   worker->CreateWorker(instance);
   FOR_EACH_OBSERVER(
       WorkerServiceObserver, observers_,
       WorkerCreated(instance.url(), instance.name(), worker->GetData().id,
                     instance.worker_route_id()));
   WorkerDevToolsManager::GetInstance()->WorkerCreated(worker, instance);
   return true;
 }
 
-WorkerProcessHost* WorkerServiceImpl::GetProcessForDomain(const GURL& url) {
-  int num_processes = 0;
-  std::string domain =
-      net::RegistryControlledDomainService::GetDomainAndRegistry(url);
-  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
-    num_processes++;
-    for (WorkerProcessHost::Instances::const_iterator instance =
-             iter->instances().begin();
-         instance != iter->instances().end(); ++instance) {
-      if (net::RegistryControlledDomainService::GetDomainAndRegistry(
-              instance->url()) == domain) {
-        return *iter;
-      }
-    }
-  }
-
-  if (num_processes >= kMaxWorkerProcessesWhenSharing)
-    return GetLeastLoadedWorker();
-
-  return NULL;
-}
-
-WorkerProcessHost* WorkerServiceImpl::GetProcessToFillUpCores() {
-  int num_processes = 0;
-  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter)
-    num_processes++;
-
-  if (num_processes >= base::SysInfo::NumberOfProcessors())
-    return GetLeastLoadedWorker();
-
-  return NULL;
-}
-
-WorkerProcessHost* WorkerServiceImpl::GetLeastLoadedWorker() {
-  WorkerProcessHost* smallest = NULL;
-  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
-    if (!smallest || iter->instances().size() < smallest->instances().size())
-      smallest = *iter;
-  }
-
-  return smallest;
-}
-
 bool WorkerServiceImpl::CanCreateWorkerProcess(
     const WorkerProcessHost::WorkerInstance& instance) {
   // Worker can be fired off if *any* parent has room.
   const WorkerDocumentSet::DocumentInfoSet& parents =
         instance.worker_document_set()->documents();
 
   for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
            parents.begin();
        parent_iter != parents.end(); ++parent_iter) {
     bool hit_total_worker_limit = false;
@@ skipping 207 matching lines @@
     return instance;
 
   // No existing pending worker - create a new one.
   WorkerProcessHost::WorkerInstance pending(
       url, true, name, resource_context, partition);
   pending_shared_workers_.push_back(pending);
   return &pending_shared_workers_.back();
 }
 
 }  // namespace content