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(
       net::URLRequestContext* url_request_context)
       : url_request_context_(url_request_context) {
   }
   virtual ~URLRequestContextSelector() {}
 
   virtual net::URLRequestContext* GetRequestContext(
       ResourceType::Type resource_type) {
     return url_request_context_;
   }
 
  private:
   net::URLRequestContext* url_request_context_;
 };
 
+std::vector<std::pair<int, int> > GetRenderViewIDsForWorker(
+    WorkerProcessHost* process,
+    int worker_route_id) {
+  std::vector<std::pair<int, int> > result;

[Andrew T Wilson (Slow), 2012/02/01 05:51:37]

How many copies of the vector does this end up creating? Is the compiler smart
enough to avoid copying into the return value? The alternative would be to pass
in a vector*. Not a huge deal, though - I'm OK as-is since in general this is a
very small vector.

Is there a reason why this isn't a member function on WorkerProcessHost?

Also, can |process| be a const in-param?

[jam, 2012/02/01 16:53:53]

yep: see http://en.wikipedia.org/wiki/Return_value_optimization
no reason. i'll just make it a member function

+  WorkerProcessHost::Instances::const_iterator i;
+  for (i = process->instances().begin(); i != process->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;
+}
+
 }  // namespace
 
 // Notifies RenderViewHost that one or more worker objects crashed.
 void WorkerCrashCallback(int render_process_unique_id, int render_view_id) {
   RenderViewHost* host =
       RenderViewHost::FromID(render_process_unique_id, render_view_id);
   if (host)
     host->delegate()->WorkerCrashed();
 }
 
@@ skipping 277 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(this, 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(this, 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 187 matching lines @@
     }
   }
   return false;
 }
 
 WorkerProcessHost::WorkerInstance::FilterInfo
 WorkerProcessHost::WorkerInstance::GetFilter() const {
   DCHECK(NumFilters() == 1);
   return *filters_.begin();
 }