[DevTools] Support multiple sessions in Target domain

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

 /*
  * 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 25 matching lines @@
 #include "platform/wtf/RefPtr.h"
 #include "platform/wtf/text/WTFString.h"
 
 namespace blink {
 
 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) {}
 
 InspectorWorkerAgent::~InspectorWorkerAgent() {}
 
 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();
 }
 
 Response InspectorWorkerAgent::disable() {
   if (AutoAttachEnabled()) {
     DisconnectFromAllProxies(false);
     instrumenting_agents_->removeInspectorWorkerAgent(this);
   }
   state_->setBoolean(WorkerAgentState::kAutoAttach, false);
   state_->setBoolean(WorkerAgentState::kWaitForDebuggerOnStart, false);
-  state_->remove(WorkerAgentState::kAttachedWorkerIds);
+  state_->remove(WorkerAgentState::kAttachedProtocolIds);
   return Response::OK();
 }
 
 Response InspectorWorkerAgent::setAutoAttach(bool auto_attach,
                                              bool wait_for_debugger_on_start) {
   state_->setBoolean(WorkerAgentState::kWaitForDebuggerOnStart,
                      wait_for_debugger_on_start);
 
   if (auto_attach == AutoAttachEnabled())
     return Response::OK();
   state_->setBoolean(WorkerAgentState::kAutoAttach, auto_attach);
   if (auto_attach) {
     instrumenting_agents_->addInspectorWorkerAgent(this);
     ConnectToAllProxies();
   } else {
     DisconnectFromAllProxies(true);
     instrumenting_agents_->removeInspectorWorkerAgent(this);
   }
   return Response::OK();
 }
 
 Response InspectorWorkerAgent::setAttachToFrames(bool attach) {
   return Response::OK();
 }
 
 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();
 }
 
 void InspectorWorkerAgent::SetTracingSessionId(
     const String& tracing_session_id) {
   tracing_session_id_ = tracing_session_id;
   if (tracing_session_id.IsEmpty())
     return;
   for (auto& id_proxy : connected_proxies_)
     id_proxy.value->WriteTimelineStartedEvent(tracing_session_id);
 }
 
 void InspectorWorkerAgent::ShouldWaitForDebuggerOnWorkerStart(bool* result) {
   if (AutoAttachEnabled() &&
       state_->booleanProperty(WorkerAgentState::kWaitForDebuggerOnStart, false))
     *result = true;
 }
 
 void InspectorWorkerAgent::DidStartWorker(WorkerInspectorProxy* proxy,
                                           bool waiting_for_debugger) {
   DCHECK(GetFrontend() && AutoAttachEnabled());
   ConnectToProxy(proxy, waiting_for_debugger);
   if (!tracing_session_id_.IsEmpty())
     proxy->WriteTimelineStartedEvent(tracing_session_id_);
 }
 
 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() {
   for (WorkerInspectorProxy* proxy : WorkerInspectorProxy::AllProxies()) {
     // For now we assume this is document. TODO(kinuko): Fix this.
     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();
 }
 
 void InspectorWorkerAgent::DidCommitLoadForLocalFrame(LocalFrame* frame) {
   if (!AutoAttachEnabled() || frame != inspected_frames_->Root())
     return;
 
   // 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())
                                       .setUrl(proxy->Url())
                                       .build(),
                                   waiting_for_debugger);
 }
 
 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) {
   visitor->Trace(connected_proxies_);
   visitor->Trace(inspected_frames_);
   InspectorBaseAgent::Trace(visitor);
 }
 
 }  // namespace blink