Hide WorkerProcessHost from chrome.

content/browser/worker_host/worker_process_host.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_process_host.h"
 
 #include <set>
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/browser/appcache/appcache_dispatcher_host.h"
 #include "content/browser/browser_child_process_host_impl.h"
 #include "content/browser/child_process_security_policy.h"
+#include "content/browser/debugger/worker_devtools_manager.h"
 #include "content/browser/debugger/worker_devtools_message_filter.h"
 #include "content/browser/file_system/file_system_dispatcher_host.h"
 #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/socket_stream_dispatcher_host.h"
 #include "content/browser/resource_context.h"
 #include "content/browser/worker_host/message_port_service.h"
@@ skipping 14 matching lines @@
 #include "net/base/registry_controlled_domain.h"
 #include "ui/base/ui_base_switches.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/sandbox_mount_point_provider.h"
 #include "webkit/glue/resource_type.h"
 
 using content::BrowserThread;
 using content::ChildProcessData;
 using content::ChildProcessHost;
 using content::UserMetricsAction;
+using content::WorkerDevToolsManager;
 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(
@@ skipping 301 matching lines @@
   }
 }
 
 void WorkerProcessHost::OnAllowDatabase(int worker_route_id,
                                         const GURL& url,
                                         const string16& name,
                                         const string16& display_name,
                                         unsigned long estimated_size,
                                         bool* result) {
   *result = content::GetContentClient()->browser()->AllowWorkerDatabase(
-      worker_route_id, url, name, display_name, estimated_size, this);
+      url, name, display_name, estimated_size, *resource_context_,
+      GetRenderViewIDsForWorker(worker_route_id));
 }
 
 void WorkerProcessHost::OnAllowFileSystem(int worker_route_id,
                                           const GURL& url,
                                           bool* result) {
   *result = content::GetContentClient()->browser()->AllowWorkerFileSystem(
-      worker_route_id, url, this);
+      url, *resource_context_,
+      GetRenderViewIDsForWorker(worker_route_id));
 }
 
 void WorkerProcessHost::RelayMessage(
     const IPC::Message& message,
     WorkerMessageFilter* filter,
     int route_id) {
   if (message.type() == WorkerMsg_PostMessage::ID) {
     // We want to send the receiver a routing id for the new channel, so
     // crack the message first.
     string16 msg;
@@ skipping 39 matching lines @@
         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) {
-      WorkerServiceImpl::GetInstance()->NotifyWorkerContextStarted(
+      WorkerDevToolsManager::GetInstance()->WorkerContextStarted(
           this, route_id);
     }
     return;
   }
 }
 
 void WorkerProcessHost::FilterShutdown(WorkerMessageFilter* filter) {
   for (Instances::iterator i = instances_.begin(); i != instances_.end();) {
     bool shutdown = false;
     i->RemoveFilters(filter);
@@ skipping 64 matching lines @@
 }
 
 void WorkerProcessHost::TerminateWorker(int worker_route_id) {
   Send(new WorkerMsg_TerminateWorkerContext(worker_route_id));
 }
 
 const ChildProcessData& WorkerProcessHost::GetData() {
   return process_->GetData();
 }
 
+std::vector<std::pair<int, int> > WorkerProcessHost::GetRenderViewIDsForWorker(
+    int worker_route_id) {
+  std::vector<std::pair<int, int> > result;
+  WorkerProcessHost::Instances::const_iterator i;
+  for (i = instances_.begin(); i != instances_.end(); ++i) {
+    if (i->worker_route_id() != worker_route_id)
+      continue;
+    const WorkerDocumentSet::DocumentInfoSet& documents =
+        i->worker_document_set()->documents();
+    for (WorkerDocumentSet::DocumentInfoSet::const_iterator doc =
+         documents.begin(); doc != documents.end(); ++doc) {
+      result.push_back(
+          std::make_pair(doc->render_process_id(), doc->render_view_id()));
+    }
+    break;
+  }
+  return result;
+}
+
 WorkerProcessHost::WorkerInstance::WorkerInstance(
     const GURL& url,
     const string16& name,
     int worker_route_id,
     int parent_process_id,
     int64 main_resource_appcache_id,
     const content::ResourceContext* resource_context)
     : url_(url),
       closed_(false),
       name_(name),
@@ skipping 103 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }