[DevTools] Support multiple sessions in Target domain

third_party/WebKit/Source/core/inspector/InspectorWorkerAgent.cpp

Index: third_party/WebKit/Source/core/inspector/InspectorWorkerAgent.cpp
diff --git a/third_party/WebKit/Source/core/inspector/InspectorWorkerAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorWorkerAgent.cpp
index fead9045b36c302993f7c81b7e17ea82a0d326af..2b6720066b5bbe42e8f68d9ca90e3ea2864d2fe9 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorWorkerAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorWorkerAgent.cpp
@@ -43,13 +43,10 @@ using protocol::Response;
 namespace WorkerAgentState {
 static const char kAutoAttach[] = "autoAttach";
 static const char kWaitForDebuggerOnStart[] = "waitForDebuggerOnStart";
-static const char kAttachedWorkerIds[] = "attachedWorkerIds";
+static const char kAttachedProtocolIds[] = "attachedProtocolIds";
 };
 
-namespace {
-// TODO(dgozman): support multiple sessions in protocol.
-static const int kSessionId = 1;
-}  // namespace
+int InspectorWorkerAgent::last_session_id_ = 0;
 
 InspectorWorkerAgent::InspectorWorkerAgent(InspectedFrames* inspected_frames)
     : inspected_frames_(inspected_frames) {}
@@ -60,10 +57,10 @@ void InspectorWorkerAgent::Restore() {
   if (!AutoAttachEnabled())
     return;
   instrumenting_agents_->addInspectorWorkerAgent(this);
-  protocol::DictionaryValue* attached = AttachedWorkerIds();
+  protocol::DictionaryValue* attached = AttachedProtocolIds();
   for (size_t i = 0; i < attached->size(); ++i)
     GetFrontend()->detachedFromTarget(attached->at(i).first);
-  state_->remove(WorkerAgentState::kAttachedWorkerIds);
+  state_->remove(WorkerAgentState::kAttachedProtocolIds);
   ConnectToAllProxies();
 }
 
@@ -74,7 +71,7 @@ Response InspectorWorkerAgent::disable() {
   }
   state_->setBoolean(WorkerAgentState::kAutoAttach, false);
   state_->setBoolean(WorkerAgentState::kWaitForDebuggerOnStart, false);
-  state_->remove(WorkerAgentState::kAttachedWorkerIds);
+  state_->remove(WorkerAgentState::kAttachedProtocolIds);
   return Response::OK();
 }
 
@@ -104,12 +101,14 @@ bool InspectorWorkerAgent::AutoAttachEnabled() {
   return state_->booleanProperty(WorkerAgentState::kAutoAttach, false);
 }
 
-Response InspectorWorkerAgent::sendMessageToTarget(const String& target_id,
+Response InspectorWorkerAgent::sendMessageToTarget(const String& session_id,
                                                    const String& message) {
-  WorkerInspectorProxy* proxy = connected_proxies_.at(target_id);
-  if (!proxy)
-    return Response::Error("Not attached to a target with given id");
-  proxy->SendMessageToInspector(kSessionId, message);
+  auto it = protocol_to_session_id_.find(session_id);

[caseq, 2017/06/27 18:29:30]

This now looks confusing -- should we call the parameter protocol_id? Should we
call int identifiers differently?

+  if (it == protocol_to_session_id_.end())
+    return Response::Error("No session with given id");
+  WorkerInspectorProxy* proxy = connected_proxies_.at(it->value);
+  DCHECK(proxy);

[caseq, 2017/06/27 18:29:30]

No need for a DCHECK() in a case like this -- you'll crash soon anyway.

+  proxy->SendMessageToInspector(it->value, message);
   return Response::OK();
 }
 
@@ -138,12 +137,20 @@ void InspectorWorkerAgent::DidStartWorker(WorkerInspectorProxy* proxy,
 
 void InspectorWorkerAgent::WorkerTerminated(WorkerInspectorProxy* proxy) {
   DCHECK(GetFrontend() && AutoAttachEnabled());
-  if (connected_proxies_.find(proxy->InspectorId()) == connected_proxies_.end())
-    return;
-  AttachedWorkerIds()->remove(proxy->InspectorId());
-  GetFrontend()->detachedFromTarget(proxy->InspectorId());
-  proxy->DisconnectFromInspector(kSessionId, this);
-  connected_proxies_.erase(proxy->InspectorId());
+  Vector<String> protocol_ids;
+  for (auto& it : protocol_to_session_id_) {
+    if (connected_proxies_.at(it.value) == proxy)
+      protocol_ids.push_back(it.key);
+  }
+  for (const String& protocol_id : protocol_ids) {
+    AttachedProtocolIds()->remove(protocol_id);
+    GetFrontend()->detachedFromTarget(protocol_id);
+    int session_id = protocol_to_session_id_.at(protocol_id);
+    proxy->DisconnectFromInspector(session_id, this);
+    connected_proxies_.erase(session_id);
+    protocol_to_session_id_.erase(protocol_id);
+    session_to_protocol_id_.erase(session_id);
+  }
 }
 
 void InspectorWorkerAgent::ConnectToAllProxies() {
@@ -152,19 +159,22 @@ void InspectorWorkerAgent::ConnectToAllProxies() {
     DCHECK(proxy->GetExecutionContext()->IsDocument());
     Document* document = ToDocument(proxy->GetExecutionContext());
     if (document->GetFrame() &&
-        inspected_frames_->Contains(document->GetFrame()))
+        inspected_frames_->Contains(document->GetFrame())) {
       ConnectToProxy(proxy, false);
+    }
   }
 }
 
 void InspectorWorkerAgent::DisconnectFromAllProxies(bool report_to_frontend) {
-  for (auto& id_proxy : connected_proxies_) {
+  for (auto& it : protocol_to_session_id_) {
     if (report_to_frontend) {
-      AttachedWorkerIds()->remove(id_proxy.key);
-      GetFrontend()->detachedFromTarget(id_proxy.key);
+      AttachedProtocolIds()->remove(it.key);
+      GetFrontend()->detachedFromTarget(it.key);
     }
-    id_proxy.value->DisconnectFromInspector(kSessionId, this);
+    connected_proxies_.at(it.value)->DisconnectFromInspector(it.value, this);
   }
+  protocol_to_session_id_.clear();
+  session_to_protocol_id_.clear();
   connected_proxies_.clear();
 }
 
@@ -175,33 +185,36 @@ void InspectorWorkerAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
   // During navigation workers from old page may die after a while.
   // Usually, it's fine to report them terminated later, but some tests
   // expect strict set of workers, and we reuse renderer between tests.
-  for (auto& id_proxy : connected_proxies_) {
-    AttachedWorkerIds()->remove(id_proxy.key);
-    GetFrontend()->detachedFromTarget(id_proxy.key);
-    id_proxy.value->DisconnectFromInspector(kSessionId, this);
-  }
-  connected_proxies_.clear();
+  DisconnectFromAllProxies(true);
 }
 
-protocol::DictionaryValue* InspectorWorkerAgent::AttachedWorkerIds() {
+protocol::DictionaryValue* InspectorWorkerAgent::AttachedProtocolIds() {
   protocol::DictionaryValue* ids =
-      state_->getObject(WorkerAgentState::kAttachedWorkerIds);
+      state_->getObject(WorkerAgentState::kAttachedProtocolIds);
   if (!ids) {
     std::unique_ptr<protocol::DictionaryValue> new_ids =
         protocol::DictionaryValue::create();
     ids = new_ids.get();
-    state_->setObject(WorkerAgentState::kAttachedWorkerIds, std::move(new_ids));
+    state_->setObject(WorkerAgentState::kAttachedProtocolIds,
+                      std::move(new_ids));
   }
   return ids;
 }
 
 void InspectorWorkerAgent::ConnectToProxy(WorkerInspectorProxy* proxy,
                                           bool waiting_for_debugger) {
-  connected_proxies_.Set(proxy->InspectorId(), proxy);
-  proxy->ConnectToInspector(kSessionId, this);
+  int session_id = ++last_session_id_;

[caseq, 2017/06/27 18:29:30]

This looks more line proxy_id to me -- the word session is a bit overloaded.

+  connected_proxies_.Set(session_id, proxy);
+
+  String protocol_id = proxy->InspectorId() + "-" + String::Number(session_id);
+  protocol_to_session_id_.Set(protocol_id, session_id);
+  session_to_protocol_id_.Set(session_id, protocol_id);
+
+  proxy->ConnectToInspector(session_id, this);
   DCHECK(GetFrontend());
-  AttachedWorkerIds()->setBoolean(proxy->InspectorId(), true);
-  GetFrontend()->attachedToTarget(protocol::Target::TargetInfo::create()
+  AttachedProtocolIds()->setBoolean(protocol_id, true);
+  GetFrontend()->attachedToTarget(protocol_id,
+                                  protocol::Target::TargetInfo::create()
                                       .setTargetId(proxy->InspectorId())
                                       .setType("worker")
                                       .setTitle(proxy->Url())
@@ -214,8 +227,10 @@ void InspectorWorkerAgent::DispatchMessageFromWorker(
     WorkerInspectorProxy* proxy,
     int session_id,
     const String& message) {
-  DCHECK(session_id == kSessionId);
-  GetFrontend()->receivedMessageFromTarget(proxy->InspectorId(), message);
+  auto it = session_to_protocol_id_.find(session_id);
+  if (it == session_to_protocol_id_.end())
+    return;
+  GetFrontend()->receivedMessageFromTarget(it->value, message);
 }
 
 DEFINE_TRACE(InspectorWorkerAgent) {