Create an API around WorkerService that chrome consumes. Rename the existing WorkerService to Wor...

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 11 matching lines @@
 #include "content/browser/mime_registry_message_filter.h"
 #include "content/browser/renderer_host/blob_message_filter.h"
 #include "content/browser/renderer_host/database_message_filter.h"
 #include "content/browser/renderer_host/file_utilities_message_filter.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/socket_stream_dispatcher_host.h"
 #include "content/browser/resource_context.h"
 #include "content/browser/worker_host/message_port_service.h"
 #include "content/browser/worker_host/worker_message_filter.h"
-#include "content/browser/worker_host/worker_service.h"
+#include "content/browser/worker_host/worker_service_impl.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/common/debug_flags.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "ipc/ipc_switches.h"
 #include "net/base/mime_util.h"
 #include "net/base/registry_controlled_domain.h"
 #include "ui/base/ui_base_switches.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_path_manager.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/glue/resource_type.h"
 
 using content::BrowserThread;
 using content::ChildProcessHost;
 using content::UserMetricsAction;
+using content::WorkerServiceImpl;
 
 namespace {
 
 // Helper class that we pass to SocketStreamDispatcherHost so that it can find
 // the right net::URLRequestContext for a request.
 class URLRequestContextSelector
     : public ResourceMessageFilter::URLRequestContextSelector {
  public:
   explicit URLRequestContextSelector(
       net::URLRequestContext* url_request_context)
@@ skipping 35 matching lines @@
   for (Instances::iterator i = instances_.begin(); i != instances_.end(); ++i) {
     const WorkerDocumentSet::DocumentInfoSet& parents =
         i->worker_document_set()->documents();
     for (WorkerDocumentSet::DocumentInfoSet::const_iterator parent_iter =
              parents.begin(); parent_iter != parents.end(); ++parent_iter) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           base::Bind(&WorkerCrashCallback, parent_iter->render_process_id(),
                      parent_iter->render_view_id()));
     }
-    WorkerService::GetInstance()->NotifyWorkerDestroyed(this,
-                                                        i->worker_route_id());
+    WorkerServiceImpl::GetInstance()->NotifyWorkerDestroyed(
+        this, i->worker_route_id());
   }
 
   ChildProcessSecurityPolicy::GetInstance()->Remove(id());
 }
 
 bool WorkerProcessHost::Init(int render_process_id) {
   std::string channel_id = child_process_host()->CreateChannel();
   if (channel_id.empty())
     return false;
 
@@ skipping 117 matching lines @@
       resource_context_->request_context();
 
   ResourceMessageFilter* resource_message_filter = new ResourceMessageFilter(
       id(), content::PROCESS_TYPE_WORKER, resource_context_,
       new URLRequestContextSelector(request_context),
       resource_dispatcher_host_);
   child_process_host()->AddFilter(resource_message_filter);
 
   worker_message_filter_ = new WorkerMessageFilter(
       render_process_id, resource_context_, resource_dispatcher_host_,
-      base::Bind(&WorkerService::next_worker_route_id,
-                 base::Unretained(WorkerService::GetInstance())));
+      base::Bind(&WorkerServiceImpl::next_worker_route_id,
+                 base::Unretained(WorkerServiceImpl::GetInstance())));
   child_process_host()->AddFilter(worker_message_filter_);
   child_process_host()->AddFilter(new AppCacheDispatcherHost(
       resource_context_->appcache_service(), id()));
   child_process_host()->AddFilter(new FileSystemDispatcherHost(
       request_context, resource_context_->file_system_context()));
   child_process_host()->AddFilter(new FileUtilitiesMessageFilter(id()));
   child_process_host()->AddFilter(new BlobMessageFilter(
       id(), resource_context_->blob_storage_context()));
   child_process_host()->AddFilter(new MimeRegistryMessageFilter());
   child_process_host()->AddFilter(new DatabaseMessageFilter(
@@ skipping 62 matching lines @@
   if (!msg_is_ok) {
     NOTREACHED();
     content::RecordAction(UserMetricsAction("BadMessageTerminate_WPH"));
     base::KillProcess(handle(), content::RESULT_CODE_KILLED_BAD_MESSAGE, false);
   }
 
   if (handled)
     return true;
 
   if (message.type() == WorkerHostMsg_WorkerContextDestroyed::ID) {
-    WorkerService::GetInstance()->NotifyWorkerDestroyed(this,
-                                                        message.routing_id());
+    WorkerServiceImpl::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 (message.type() == WorkerHostMsg_WorkerContextDestroyed::ID) {
         instances_.erase(i);
         UpdateTitle();
       }
       return true;
     }
@@ skipping 81 matching lines @@
     filter->Send(new WorkerMsg_Connect(
         route_id, sent_message_port_id, new_routing_id));
 
     // Send any queued messages for the sent port.
     MessagePortService::GetInstance()->SendQueuedMessagesIfPossible(
         sent_message_port_id);
   } else {
     IPC::Message* new_message = new IPC::Message(message);
     new_message->set_routing_id(route_id);
     filter->Send(new_message);
-    if (message.type() == WorkerMsg_StartWorkerContext::ID)
-      WorkerService::GetInstance()->NotifyWorkerContextStarted(this, route_id);
+    if (message.type() == WorkerMsg_StartWorkerContext::ID) {
+      WorkerServiceImpl::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);
 
     i->worker_document_set()->RemoveAll(filter);
@@ skipping 181 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }