Revert of [DevTools] Remove isRunRequired, replace autoConnectToWorkers with setWaitForDebuggerOnStart.

third_party/WebKit/Source/devtools/front_end/sdk/WorkerManager.js

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 68 matching lines @@
     {
         for (var connection of this._connections.values())
             connection._close();
         this._connections.clear();
         this._targetsByWorkerId.clear();
     },
 
     _onSuspendStateChanged: function()
     {
         var suspended = WebInspector.targetManager.allTargetsSuspended();
-        this.target().workerAgent().setWaitForDebuggerOnStart(!suspended);
+        this.target().workerAgent().setAutoconnectToWorkers(!suspended);
     },
 
     /**
      * @param {string} workerId
      * @param {string} url
-     * @param {boolean} waitingForDebugger
+     * @param {boolean} inspectorConnected
      */
-    _workerCreated: function(workerId, url, waitingForDebugger)
+    _workerCreated: function(workerId, url, inspectorConnected)
     {
-        var connection = new WebInspector.WorkerConnection(this, workerId);
+        var connection = new WebInspector.WorkerConnection(this, workerId, inspectorConnected, onConnectionReady.bind(this));
         this._connections.set(workerId, connection);
 
-        var parsedURL = url.asParsedURL();
-        var workerName = parsedURL ? parsedURL.lastPathComponentWithFragment() : "#" + (++this._lastAnonymousTargetId);
-        var target = WebInspector.targetManager.createTarget(workerName, WebInspector.Target.Type.DedicatedWorker, connection, this.target());
-        this._targetsByWorkerId.set(workerId, target);
+        /**
+         * @param {!InspectorBackendClass.Connection} connection
+         * @this {WebInspector.WorkerManager}
+         */
+        function onConnectionReady(connection)
+        {
+            var parsedURL = url.asParsedURL();
+            var workerName = parsedURL ? parsedURL.lastPathComponentWithFragment() : "#" + (++this._lastAnonymousTargetId);
+            var target = WebInspector.targetManager.createTarget(workerName, WebInspector.Target.Type.DedicatedWorker, connection, this.target());
+            this._targetsByWorkerId.set(workerId, target);
 
-        // Only pause new worker if debugging SW - we are going through the
-        // pause on start checkbox.
-        var mainIsServiceWorker = WebInspector.targetManager.mainTarget().isServiceWorker();
-        if (mainIsServiceWorker && waitingForDebugger)
-            target.debuggerAgent().pause();
-        target.runtimeAgent().run();
+            if (inspectorConnected)
+                target.runtimeAgent().isRunRequired(pauseInDebuggerAndRunIfRequired.bind(null, target));
+        }
+
+        /**
+         * @param {!WebInspector.Target} target
+         * @param {?Protocol.Error} error
+         * @param {boolean} required
+         */
+        function pauseInDebuggerAndRunIfRequired(target, error, required)
+        {
+            // Only pause new worker if debugging SW - we are going through the
+            // pause on start checkbox.
+            var mainIsServiceWorker = WebInspector.targetManager.mainTarget().isServiceWorker();
+            if (mainIsServiceWorker && required)
+                target.debuggerAgent().pause();
+            target.runtimeAgent().run();
+        }
     },
 
     /**
      * @param {string} workerId
      */
     _workerTerminated: function(workerId)
     {
         var connection = this._connections.get(workerId);
         if (connection)
             connection._close();
@@ skipping 39 matching lines @@
 WebInspector.WorkerDispatcher = function(workerManager)
 {
     this._workerManager = workerManager;
 }
 
 WebInspector.WorkerDispatcher.prototype = {
     /**
      * @override
      * @param {string} workerId
      * @param {string} url
-     * @param {boolean} waitingForDebugger
+     * @param {boolean} inspectorConnected
      */
-    workerCreated: function(workerId, url, waitingForDebugger)
+    workerCreated: function(workerId, url, inspectorConnected)
     {
-        this._workerManager._workerCreated(workerId, url, waitingForDebugger);
+        this._workerManager._workerCreated(workerId, url, inspectorConnected);
     },
 
     /**
      * @override
      * @param {string} workerId
      */
     workerTerminated: function(workerId)
     {
         this._workerManager._workerTerminated(workerId);
     },
 
     /**
      * @override
      * @param {string} workerId
      * @param {string} message
      */
     dispatchMessageFromWorker: function(workerId, message)
     {
         this._workerManager._dispatchMessageFromWorker(workerId, message);
     }
 }
 
 /**
  * @constructor
  * @extends {InspectorBackendClass.Connection}
  * @param {!WebInspector.WorkerManager} workerManager
  * @param {string} workerId
+ * @param {boolean} inspectorConnected
+ * @param {function(!InspectorBackendClass.Connection)} onConnectionReady
  */
-WebInspector.WorkerConnection = function(workerManager, workerId)
+WebInspector.WorkerConnection = function(workerManager, workerId, inspectorConnected, onConnectionReady)
 {
     InspectorBackendClass.Connection.call(this);
     //FIXME: remove resourceTreeModel and others from worker targets
     this.suppressErrorsForDomains(["Worker", "Page", "CSS", "DOM", "DOMStorage", "Database", "Network", "IndexedDB"]);
     this._agent = workerManager.target().workerAgent();
     this._workerId = workerId;
+
+
+    if (!inspectorConnected)
+        this._agent.connectToWorker(workerId, onConnectionReady.bind(null, this));
+    else
+        onConnectionReady.call(null, this);
 }
 
 WebInspector.WorkerConnection.prototype = {
     /**
      * @override
      * @param {!Object} messageObject
      */
     sendMessage: function(messageObject)
     {
         this._agent.sendMessageToWorker(this._workerId, JSON.stringify(messageObject));
     },
 
     _close: function()
     {
         this.connectionClosed("worker_terminated");
     },
 
     __proto__: InspectorBackendClass.Connection.prototype
 }