[DevTools] Support multiple sessions in Target domain

third_party/WebKit/LayoutTests/inspector-protocol/resources/inspector-protocol-test.js

 // Copyright 2017 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.
 
 var TestRunner = class {
   constructor(baseURL, log, completeTest, fetch) {
     this._dumpInspectorProtocolMessages = false;
     this._baseURL = baseURL;
     this._log = log;
     this._completeTest = completeTest;
@@ skipping 149 matching lines @@
   }
 };
 
 TestRunner.Page = class {
   constructor(testRunner, targetId) {
     this._testRunner = testRunner;
     this._targetId = targetId;
   }
 
   async createSession() {
-    await DevToolsAPI._sendCommandOrDie('Target.attachToTarget', {targetId: this._targetId});
-    var session = new TestRunner.Session(this);
-    DevToolsAPI._sessions.set(this._targetId, session);
+    var sessionId = (await DevToolsAPI._sendCommandOrDie('Target.attachToTarget', {targetId: this._targetId})).sessionId;
+    var session = new TestRunner.Session(this, sessionId);
+    DevToolsAPI._sessions.set(sessionId, session);
     return session;
   }
 
   navigate(url) {
     return this._navigate(this._testRunner.url(url));
   }
 
   async _navigate(url) {
-    if (DevToolsAPI._sessions.get(this._targetId))
-      this._testRunner.die(`Cannot navigate to ${url} with active session`, new Error());
-
     var session = await this.createSession();
     session.protocol.Page.enable();
     session.protocol.Page.navigate({url: url});
 
     var callback;
     var promise = new Promise(f => callback = f);
     session.protocol.Page.onFrameNavigated(message => {
       if (!message.params.frame.parentId)
         callback();
     });
     await promise;
 
     await session.disconnect();
   }
 
   async loadHTML(html) {
-    if (DevToolsAPI._sessions.get(this._targetId))
-      this._testRunner.die('Cannot loadHTML with active session', new Error());
-
     html = html.replace(/'/g, "\\'").replace(/\n/g, '\\n');
     var session = await this.createSession();
     await session.protocol.Runtime.evaluate({expression: `document.body.innerHTML='${html}'`});
     await session.disconnect();
   }
 };
 
 TestRunner.Session = class {
-  constructor(page) {
+  constructor(page, sessionId) {
     this._testRunner = page._testRunner;
     this._page = page;
+    this._sessionId = sessionId;
     this._requestId = 0;
     this._dispatchTable = new Map();
     this._eventHandlers = new Map();
     this.protocol = this._setupProtocol();
   }
 
   async disconnect() {
-    await DevToolsAPI._sendCommandOrDie('Target.detachFromTarget', {targetId: this._page._targetId});
-    DevToolsAPI._sessions.delete(this._page._targetId);
+    await DevToolsAPI._sendCommandOrDie('Target.detachFromTarget', {sessionId: this._sessionId});
+    DevToolsAPI._sessions.delete(this._sessionId);
   }
 
   sendRawCommand(requestId, message) {
-    DevToolsAPI._sendCommandOrDie('Target.sendMessageToTarget', {targetId: this._page._targetId, message: message});
+    DevToolsAPI._sendCommandOrDie('Target.sendMessageToTarget', {sessionId: this._sessionId, message: message});
     return new Promise(f => this._dispatchTable.set(requestId, f));
   }
 
   sendCommand(method, params) {
     var requestId = ++this._requestId;
     var messageObject = {'id': requestId, 'method': method, 'params': params};
     if (this._testRunner._dumpInspectorProtocolMessages)
       this._testRunner.log(`frontend => backend: ${JSON.stringify(messageObject)}`);
     return this.sendRawCommand(requestId, JSON.stringify(messageObject));
   }
@@ skipping 117 matching lines @@
   try {
     if (typeof messageId === 'number') {
       var handler = DevToolsAPI._dispatchTable.get(messageId);
       if (handler) {
         DevToolsAPI._dispatchTable.delete(messageId);
         handler(messageObject);
       }
     } else {
       var eventName = messageObject.method;
       if (eventName === 'Target.receivedMessageFromTarget') {
-        var targetId = messageObject.params.targetId;
+        var sessionId = messageObject.params.sessionId;
         var message = messageObject.params.message;
-        var session = DevToolsAPI._sessions.get(targetId);
+        var session = DevToolsAPI._sessions.get(sessionId);
         if (session)
           session._dispatchMessage(JSON.parse(message));
       }
     }
   } catch(e) {
     DevToolsAPI._die(`Exception when dispatching message\n${JSON.stringify(messageObject)}`, e);
   }
 };
 
 DevToolsAPI._sendCommand = function(method, params) {
@@ skipping 66 matching lines @@
 
 window['onerror'] = (message, source, lineno, colno, error) => {
   DevToolsAPI._log(`${error}\n${error.stack}`);
   DevToolsAPI._completeTest();
 };
 
 window.addEventListener('unhandledrejection', e => {
   DevToolsAPI._log(`Promise rejection: ${e.reason}\n${e.reason ? e.reason.stack : ''}`);
   DevToolsAPI._completeTest();
 }, false);