Add pause_on_start flag to WorkerProcessMsg_CreateWorker_Params.

DevToolsAgentMsg_PauseWorkerContextOnStart was send to the worker process from the browser process in order to pause the worker context when it starts.
Before http://crbug.com/329786 this message was sent between WorkerProcessMsg_CreateWorker and WorkerMsg_StartWorkerContext.
So the worker was successfully paused before started.
But after http://crbug.com/329786 the worker context may be started before the worker process receives this message because WorkerMsg_StartWorkerContext is no longer sent from the browser process.
So we have to add pause_on_start flag to WorkerProcessMsg_CreateWorker_Params to pause the worker context correctly.

BUG=329786

Review URL: https://codereview.chromium.org/213423008

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@260377 0039d316-1c4b-4281-b951-d872f2087c98

content/browser/devtools/worker_devtools_manager.cc

@@ -228,7 +228,7 @@ WorkerDevToolsManager::WorkerDevToolsManager() {
 WorkerDevToolsManager::~WorkerDevToolsManager() {
 }
 
-void WorkerDevToolsManager::WorkerCreated(
+bool WorkerDevToolsManager::WorkerCreated(
     WorkerProcessHost* worker,
     const WorkerProcessHost::WorkerInstance& instance) {
   for (TerminatedInspectedWorkers::iterator it = terminated_workers_.begin();
@@ -236,14 +236,13 @@ void WorkerDevToolsManager::WorkerCreated(
     if (instance.Matches(it->worker_url, it->worker_name,
                          instance.partition(),
                          instance.resource_context())) {
-      worker->Send(new DevToolsAgentMsg_PauseWorkerContextOnStart(
-          instance.worker_route_id()));
       WorkerId new_worker_id(worker->GetData().id, instance.worker_route_id());
       paused_workers_[new_worker_id] = it->old_worker_id;
       terminated_workers_.erase(it);
-      return;
+      return true;
     }
   }
+  return false;
 }
 
 void WorkerDevToolsManager::WorkerDestroyed(

content/browser/devtools/worker_devtools_manager.h

@@ -40,7 +40,8 @@ class WorkerDevToolsManager {
                              const std::string& state);
 
   // Called on the IO thread.
-  void WorkerCreated(
+  // Returns true when the worker must be paused on start.
+  bool WorkerCreated(
       WorkerProcessHost* process,
       const WorkerProcessHost::WorkerInstance& instance);
   void WorkerDestroyed(WorkerProcessHost* process, int worker_route_id);

content/browser/worker_host/worker_process_host.cc

@@ -323,7 +323,8 @@ void WorkerProcessHost::CreateMessageFilters(int render_process_id) {
       new IndexedDBDispatcherHost(partition_.indexed_db_context()));
 }
 
-void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
+void WorkerProcessHost::CreateWorker(const WorkerInstance& instance,
+                                     bool pause_on_start) {
   ChildProcessSecurityPolicyImpl::GetInstance()->GrantRequestURL(
       process_->GetData().id, instance.url());
 
@@ -334,6 +335,7 @@ void WorkerProcessHost::CreateWorker(const WorkerInstance& instance) {
   params.name = instance.name();
   params.content_security_policy = instance.content_security_policy();
   params.security_policy_type = instance.security_policy_type();
+  params.pause_on_start = pause_on_start;
   params.route_id = instance.worker_route_id();
   Send(new WorkerProcessMsg_CreateWorker(params));
 

content/browser/worker_host/worker_process_host.h

@@ -170,7 +170,7 @@ class WorkerProcessHost : public BrowserChildProcessHostDelegate,
   bool Init(int render_process_id, int render_frame_id);
 
   // Creates a worker object in the process.
-  void CreateWorker(const WorkerInstance& instance);
+  void CreateWorker(const WorkerInstance& instance, bool pause_on_start);
 
   // Returns true iff the given message from a renderer process was forwarded to
   // the worker.

content/browser/worker_host/worker_service_impl.cc

@@ -409,12 +409,13 @@ bool WorkerServiceImpl::CreateWorkerFromInstance(
     return false;
   }
 
-  worker->CreateWorker(instance);
+  worker->CreateWorker(
+      instance,
+      WorkerDevToolsManager::GetInstance()->WorkerCreated(worker, 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;
 }
 

content/child/shared_worker_devtools_agent.cc

@@ -34,8 +34,6 @@ bool SharedWorkerDevToolsAgent::OnMessageReceived(const IPC::Message& message) {
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_Detach, OnDetach)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_DispatchOnInspectorBackend,
                         OnDispatchOnInspectorBackend)
-    IPC_MESSAGE_HANDLER(DevToolsAgentMsg_PauseWorkerContextOnStart,
-                        OnPauseWorkerContextOnStart)
     IPC_MESSAGE_HANDLER(DevToolsAgentMsg_ResumeWorkerContext,
                         OnResumeWorkerContext)
     IPC_MESSAGE_UNHANDLED(handled = false)
@@ -73,10 +71,6 @@ void SharedWorkerDevToolsAgent::OnDispatchOnInspectorBackend(
   webworker_->dispatchDevToolsMessage(WebString::fromUTF8(message));
 }
 
-void SharedWorkerDevToolsAgent::OnPauseWorkerContextOnStart() {
-  webworker_->pauseWorkerContextOnStart();
-}
-
 void SharedWorkerDevToolsAgent::OnResumeWorkerContext() {
   webworker_->resumeWorkerContext();
 }

content/child/shared_worker_devtools_agent.h

@@ -35,7 +35,6 @@ class SharedWorkerDevToolsAgent {
   void OnReattach(const std::string&);
   void OnDetach();
   void OnDispatchOnInspectorBackend(const std::string& message);
-  void OnPauseWorkerContextOnStart();
   void OnResumeWorkerContext();
 
   bool Send(IPC::Message* message);

content/common/devtools_messages.h

@@ -86,11 +86,6 @@ IPC_MESSAGE_ROUTED2(DevToolsAgentMsg_AddMessageToConsole,
                     content::ConsoleMessageLevel /* level */,
                     std::string /* message */)
 
-// Notifies worker devtools agent that it should pause worker context
-// when it starts and wait until either DevTools client is attached or
-// explicit resume notification is received.
-IPC_MESSAGE_ROUTED0(DevToolsAgentMsg_PauseWorkerContextOnStart)
-
 // Worker DevTools agent should resume worker execution.
 IPC_MESSAGE_ROUTED0(DevToolsAgentMsg_ResumeWorkerContext)
 

content/common/worker_messages.h

@@ -42,6 +42,7 @@ IPC_STRUCT_BEGIN(WorkerProcessMsg_CreateWorker_Params)
   IPC_STRUCT_MEMBER(base::string16, name)
   IPC_STRUCT_MEMBER(base::string16, content_security_policy)
   IPC_STRUCT_MEMBER(blink::WebContentSecurityPolicyType, security_policy_type)
+  IPC_STRUCT_MEMBER(bool, pause_on_start)
   IPC_STRUCT_MEMBER(int, route_id)
 IPC_STRUCT_END()
 

content/worker/websharedworker_stub.cc

@@ -23,6 +23,7 @@ WebSharedWorkerStub::WebSharedWorkerStub(
     const base::string16& name,
     const base::string16& content_security_policy,
     blink::WebContentSecurityPolicyType security_policy_type,
+    bool pause_on_start,
     int route_id)
     : route_id_(route_id),
       client_(route_id, this),
@@ -37,6 +38,11 @@ WebSharedWorkerStub::WebSharedWorkerStub(
 
   // TODO(atwilson): Add support for NaCl when they support MessagePorts.
   impl_ = blink::WebSharedWorker::create(client());
+  if (pause_on_start) {
+    // Pause worker context when it starts and wait until either DevTools client
+    // is attached or explicit resume notification is received.
+    impl_->pauseWorkerContextOnStart();
+  }
   worker_devtools_agent_.reset(new SharedWorkerDevToolsAgent(route_id, impl_));
   client()->set_devtools_agent(worker_devtools_agent_.get());
   impl_->startWorkerContext(url_, name,

content/worker/websharedworker_stub.h

@@ -30,6 +30,7 @@ class WebSharedWorkerStub : public IPC::Listener {
                       const base::string16& name,
                       const base::string16& content_security_policy,
                       blink::WebContentSecurityPolicyType security_policy_type,
+                      bool pause_on_start,
                       int route_id);
 
   // IPC::Listener implementation.

content/worker/worker_thread.cc

@@ -123,6 +123,7 @@ void WorkerThread::OnCreateWorker(
       params.name,
       params.content_security_policy,
       params.security_policy_type,
+      params.pause_on_start,
       params.route_id);
 }