[DevTools] Used generated Worker.disconnectedFromWorker

content/browser/devtools/embedded_worker_devtools_agent_host.cc

 // Copyright 2014 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.
 
 #include "content/browser/devtools/embedded_worker_devtools_agent_host.h"
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/devtools/devtools_protocol.h"
-#include "content/browser/devtools/devtools_protocol_constants.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_version.h"
 #include "content/browser/shared_worker/shared_worker_service_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 
 namespace content {
 
 namespace {
@@ skipping 17 matching lines @@
 }
 
 }
 
 EmbeddedWorkerDevToolsAgentHost::EmbeddedWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const SharedWorkerInstance& shared_worker)
     : shared_worker_(new SharedWorkerInstance(shared_worker)),
       state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
+  InitWorkerDomainClient();
   WorkerCreated();
 }
 
 EmbeddedWorkerDevToolsAgentHost::EmbeddedWorkerDevToolsAgentHost(
     WorkerId worker_id,
     const ServiceWorkerIdentifier& service_worker,
     bool debug_service_worker_on_start)
     : service_worker_(new ServiceWorkerIdentifier(service_worker)),
       state_(WORKER_UNINSPECTED),
       worker_id_(worker_id) {
   if (debug_service_worker_on_start)
     state_ = WORKER_PAUSED_FOR_DEBUG_ON_START;
+  InitWorkerDomainClient();
   WorkerCreated();
 }
 
+void EmbeddedWorkerDevToolsAgentHost::InitWorkerDomainClient() {
+  worker_domain_client_.reset(new devtools::worker::Client(
+      base::Bind(&EmbeddedWorkerDevToolsAgentHost::SendMessageToClient,
+                 base::Unretained(this))));
+}
+
 bool EmbeddedWorkerDevToolsAgentHost::IsWorker() const {
   return true;
 }
 
 DevToolsAgentHost::Type EmbeddedWorkerDevToolsAgentHost::GetType() {
   return shared_worker_ ? TYPE_SHARED_WORKER : TYPE_SERVICE_WORKER;
 }
 
 std::string EmbeddedWorkerDevToolsAgentHost::GetTitle() {
   if (shared_worker_ && shared_worker_->name().length())
@@ skipping 92 matching lines @@
   state_ = IsAttached() ? WORKER_PAUSED_FOR_REATTACH : WORKER_UNINSPECTED;
   worker_id_ = worker_id;
   WorkerCreated();
 }
 
 void EmbeddedWorkerDevToolsAgentHost::WorkerDestroyed() {
   DCHECK_NE(WORKER_TERMINATED, state_);
   if (state_ == WORKER_INSPECTED) {
     DCHECK(IsAttached());
     // Client host is debugging this worker agent host.
-    std::string notification =
-        DevToolsProtocol::CreateNotification(
-            devtools::Worker::disconnectedFromWorker::kName, NULL)->Serialize();
-    SendMessageToClient(notification);
+    worker_domain_client_->DisconnectedFromWorker(

[dgozman, 2014/11/20 14:38:07]

Let's create worker domain client right here to localize it.

[vkuzkokov, 2014/11/20 15:05:07]

Done.

+        devtools::worker::DisconnectedFromWorkerParams::Create());
     DetachFromWorker();
   }
   state_ = WORKER_TERMINATED;
   Release();  // Balanced in WorkerCreated()
 }
 
 bool EmbeddedWorkerDevToolsAgentHost::Matches(
     const SharedWorkerInstance& other) {
   return shared_worker_ && shared_worker_->Matches(other);
 }
@@ skipping 35 matching lines @@
 
   ProcessChunkedMessageFromAgent(message, total_size);
 }
 
 void EmbeddedWorkerDevToolsAgentHost::OnSaveAgentRuntimeState(
     const std::string& state) {
   saved_agent_state_ = state;
 }
 
 }  // namespace content