diff --git a/content/browser/devtools/protocol/target_auto_attacher.cc b/content/browser/devtools/protocol/target_auto_attacher.cc
index f979ec9..a5532f3 100644
--- a/content/browser/devtools/protocol/target_auto_attacher.cc
+++ b/content/browser/devtools/protocol/target_auto_attacher.cc
@@ -180,10 +180,8 @@
 
   auto matching = GetMatchingServiceWorkers(browser_context, frame_urls_);
   Hosts new_hosts;
-  for (const auto& pair : matching) {
-    if (pair.second->IsReadyForInspection())
-      new_hosts.insert(pair.second);
-  }
+  for (const auto& pair : matching)
+    new_hosts.insert(pair.second);
   ReattachTargetsOfType(new_hosts, DevToolsAgentHost::kTypeServiceWorker,
                         waiting_for_debugger);
 }
@@ -239,29 +237,22 @@
 
 // -------- ServiceWorkerDevToolsManager::Observer ----------
 
-void TargetAutoAttacher::WorkerCreated(ServiceWorkerDevToolsAgentHost* host) {
+void TargetAutoAttacher::WorkerCreated(ServiceWorkerDevToolsAgentHost* host,
+                                       bool* should_pause_on_start) {
   BrowserContext* browser_context = nullptr;
   if (render_frame_host_)
     browser_context = render_frame_host_->GetProcess()->GetBrowserContext();
   auto hosts = GetMatchingServiceWorkers(browser_context, frame_urls_);
-  if (hosts.find(host->GetId()) != hosts.end() && !host->IsAttached() &&
-      !host->IsPausedForDebugOnStart() && wait_for_debugger_on_start_) {
-    host->PauseForDebugOnStart();
+  if (hosts.find(host->GetId()) != hosts.end()) {
+    *should_pause_on_start = wait_for_debugger_on_start_;
+    Hosts new_hosts;
+    for (const auto& pair : hosts)
+      new_hosts.insert(pair.second);
+    ReattachTargetsOfType(new_hosts, DevToolsAgentHost::kTypeServiceWorker,
+                          wait_for_debugger_on_start_);
   }
 }
 
-void TargetAutoAttacher::WorkerReadyForInspection(
-    ServiceWorkerDevToolsAgentHost* host) {
-  DCHECK(host->IsReadyForInspection());
-  if (ServiceWorkerDevToolsManager::GetInstance()
-          ->debug_service_worker_on_start()) {
-    // When debug_service_worker_on_start is true, a new DevTools window will
-    // be opened in ServiceWorkerDevToolsManager::WorkerReadyForInspection.
-    return;
-  }
-  ReattachServiceWorkers(host->IsPausedForDebugOnStart());
-}
-
 void TargetAutoAttacher::WorkerVersionInstalled(
     ServiceWorkerDevToolsAgentHost* host) {
   ReattachServiceWorkers(false);
diff --git a/content/browser/devtools/protocol/target_auto_attacher.h b/content/browser/devtools/protocol/target_auto_attacher.h
index c0b00481..5af8986 100644
--- a/content/browser/devtools/protocol/target_auto_attacher.h
+++ b/content/browser/devtools/protocol/target_auto_attacher.h
@@ -46,8 +46,8 @@
                              bool waiting_for_debugger);
 
   // ServiceWorkerDevToolsManager::Observer implementation.
-  void WorkerCreated(ServiceWorkerDevToolsAgentHost* host) override;
-  void WorkerReadyForInspection(ServiceWorkerDevToolsAgentHost* host) override;
+  void WorkerCreated(ServiceWorkerDevToolsAgentHost* host,
+                     bool* should_pause_on_start) override;
   void WorkerVersionInstalled(ServiceWorkerDevToolsAgentHost* host) override;
   void WorkerVersionDoomed(ServiceWorkerDevToolsAgentHost* host) override;
   void WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) override;
diff --git a/content/browser/devtools/service_worker_devtools_agent_host.cc b/content/browser/devtools/service_worker_devtools_agent_host.cc
index 3cde8b9b..400eb0e 100644
--- a/content/browser/devtools/service_worker_devtools_agent_host.cc
+++ b/content/browser/devtools/service_worker_devtools_agent_host.cc
@@ -52,7 +52,7 @@
     bool is_installed_version,
     const base::UnguessableToken& devtools_worker_token)
     : DevToolsAgentHostImpl(devtools_worker_token.ToString()),
-      state_(WORKER_UNINSPECTED),
+      state_(WORKER_NOT_READY),
       devtools_worker_token_(devtools_worker_token),
       worker_process_id_(worker_process_id),
       worker_route_id_(worker_route_id),
@@ -116,44 +116,43 @@
 }
 
 void ServiceWorkerDevToolsAgentHost::AttachSession(DevToolsSession* session) {
-  if (state_ != WORKER_INSPECTED) {
-    state_ = WORKER_INSPECTED;
-    AttachToWorker();
-  }
-  if (RenderProcessHost* host = RenderProcessHost::FromID(worker_process_id_)) {
-    session->SetRenderer(host, nullptr);
-    host->Send(
-        new DevToolsAgentMsg_Attach(worker_route_id_, session->session_id()));
+  if (state_ == WORKER_READY) {
+    if (sessions().size() == 1) {
+      AttachToWorker();
+      BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
+                              base::BindOnce(&SetDevToolsAttachedOnIO,
+                                             context_weak_, version_id_, true));
+    }
+    if (RenderProcessHost* host =
+            RenderProcessHost::FromID(worker_process_id_)) {
+      session->SetRenderer(host, nullptr);
+      host->Send(
+          new DevToolsAgentMsg_Attach(worker_route_id_, session->session_id()));
+    }
   }
   session->SetFallThroughForNotFound(true);
   session->AddHandler(base::WrapUnique(new protocol::InspectorHandler()));
   session->AddHandler(base::WrapUnique(new protocol::NetworkHandler(GetId())));
   session->AddHandler(base::WrapUnique(new protocol::SchemaHandler()));
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::BindOnce(&SetDevToolsAttachedOnIO,
-                                         context_weak_, version_id_, true));
 }
 
 void ServiceWorkerDevToolsAgentHost::DetachSession(int session_id) {
-  if (RenderProcessHost* host = RenderProcessHost::FromID(worker_process_id_))
-    host->Send(new DevToolsAgentMsg_Detach(worker_route_id_, session_id));
-  BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
-                          base::BindOnce(&SetDevToolsAttachedOnIO,
-                                         context_weak_, version_id_, false));
-  if (state_ == WORKER_INSPECTED) {
-    state_ = WORKER_UNINSPECTED;
-    DetachFromWorker();
-  } else if (state_ == WORKER_PAUSED_FOR_REATTACH) {
-    state_ = WORKER_UNINSPECTED;
+  if (state_ == WORKER_READY) {
+    if (RenderProcessHost* host = RenderProcessHost::FromID(worker_process_id_))
+      host->Send(new DevToolsAgentMsg_Detach(worker_route_id_, session_id));
+    if (sessions().empty()) {
+      DetachFromWorker();
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::BindOnce(&SetDevToolsAttachedOnIO, context_weak_, version_id_,
+                         false));
+    }
   }
 }
 
 bool ServiceWorkerDevToolsAgentHost::DispatchProtocolMessage(
     DevToolsSession* session,
     const std::string& message) {
-  if (state_ != WORKER_INSPECTED)
-    return true;
-
   int call_id = 0;
   std::string method;
   if (session->Dispatch(message, &call_id, &method) !=
@@ -161,11 +160,14 @@
     return true;
   }
 
-  if (RenderProcessHost* host = RenderProcessHost::FromID(worker_process_id_)) {
-    host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-        worker_route_id_, session->session_id(), call_id, method, message));
-    session->waiting_messages()[call_id] = {method, message};
+  if (state_ == WORKER_READY) {
+    if (RenderProcessHost* host =
+            RenderProcessHost::FromID(worker_process_id_)) {
+      host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
+          worker_route_id_, session->session_id(), call_id, method, message));
+    }
   }
+  session->waiting_messages()[call_id] = {method, message};
   return true;
 }
 
@@ -181,53 +183,35 @@
   return handled;
 }
 
-void ServiceWorkerDevToolsAgentHost::PauseForDebugOnStart() {
-  DCHECK(state_ == WORKER_UNINSPECTED);
-  state_ = WORKER_PAUSED_FOR_DEBUG_ON_START;
-}
-
-bool ServiceWorkerDevToolsAgentHost::IsPausedForDebugOnStart() {
-  return state_ == WORKER_PAUSED_FOR_DEBUG_ON_START ||
-         state_ == WORKER_READY_FOR_DEBUG_ON_START;
-}
-
-bool ServiceWorkerDevToolsAgentHost::IsReadyForInspection() {
-  return state_ == WORKER_INSPECTED || state_ == WORKER_UNINSPECTED ||
-         state_ == WORKER_READY_FOR_DEBUG_ON_START;
-}
-
 void ServiceWorkerDevToolsAgentHost::WorkerReadyForInspection() {
-  if (state_ == WORKER_PAUSED_FOR_REATTACH) {
-    DCHECK(IsAttached());
-    state_ = WORKER_INSPECTED;
+  DCHECK_EQ(WORKER_NOT_READY, state_);
+  state_ = WORKER_READY;
+  if (!sessions().empty()) {
     AttachToWorker();
-    if (RenderProcessHost* host =
-            RenderProcessHost::FromID(worker_process_id_)) {
-      for (DevToolsSession* session : sessions()) {
-        session->SetRenderer(host, nullptr);
-        host->Send(new DevToolsAgentMsg_Reattach(
-            worker_route_id_, session->session_id(), session->state_cookie()));
-        for (const auto& pair : session->waiting_messages()) {
-          int call_id = pair.first;
-          const DevToolsSession::Message& message = pair.second;
-          host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
-              worker_route_id_, session->session_id(), call_id, message.method,
-              message.message));
-        }
-      }
-    }
     BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                             base::BindOnce(&SetDevToolsAttachedOnIO,
                                            context_weak_, version_id_, true));
-  } else if (state_ == WORKER_PAUSED_FOR_DEBUG_ON_START) {
-    state_ = WORKER_READY_FOR_DEBUG_ON_START;
+  }
+  if (RenderProcessHost* host = RenderProcessHost::FromID(worker_process_id_)) {
+    for (DevToolsSession* session : sessions()) {
+      session->SetRenderer(host, nullptr);
+      host->Send(new DevToolsAgentMsg_Reattach(
+          worker_route_id_, session->session_id(), session->state_cookie()));
+      for (const auto& pair : session->waiting_messages()) {
+        int call_id = pair.first;
+        const DevToolsSession::Message& message = pair.second;
+        host->Send(new DevToolsAgentMsg_DispatchOnInspectorBackend(
+            worker_route_id_, session->session_id(), call_id, message.method,
+            message.message));
+      }
+    }
   }
 }
 
 void ServiceWorkerDevToolsAgentHost::WorkerRestarted(int worker_process_id,
                                                      int worker_route_id) {
   DCHECK_EQ(WORKER_TERMINATED, state_);
-  state_ = IsAttached() ? WORKER_PAUSED_FOR_REATTACH : WORKER_UNINSPECTED;
+  state_ = WORKER_NOT_READY;
   worker_process_id_ = worker_process_id;
   worker_route_id_ = worker_route_id;
   RenderProcessHost* host = RenderProcessHost::FromID(worker_process_id_);
@@ -237,15 +221,13 @@
 
 void ServiceWorkerDevToolsAgentHost::WorkerDestroyed() {
   DCHECK_NE(WORKER_TERMINATED, state_);
-  if (state_ == WORKER_INSPECTED) {
-    DCHECK(IsAttached());
-    for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
-      inspector->TargetCrashed();
-    DetachFromWorker();
-    for (DevToolsSession* session : sessions())
-      session->SetRenderer(nullptr, nullptr);
-  }
   state_ = WORKER_TERMINATED;
+  for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
+    inspector->TargetCrashed();
+  for (DevToolsSession* session : sessions())
+    session->SetRenderer(nullptr, nullptr);
+  if (!sessions().empty())
+    DetachFromWorker();
 }
 
 void ServiceWorkerDevToolsAgentHost::AttachToWorker() {
diff --git a/content/browser/devtools/service_worker_devtools_agent_host.h b/content/browser/devtools/service_worker_devtools_agent_host.h
index ab2f075..f1c6c12 100644
--- a/content/browser/devtools/service_worker_devtools_agent_host.h
+++ b/content/browser/devtools/service_worker_devtools_agent_host.h
@@ -56,11 +56,8 @@
   // IPC::Listener implementation.
   bool OnMessageReceived(const IPC::Message& msg) override;
 
-  void PauseForDebugOnStart();
-  bool IsPausedForDebugOnStart();
-  bool IsReadyForInspection();
-  void WorkerReadyForInspection();
   void WorkerRestarted(int worker_process_id, int worker_route_id);
+  void WorkerReadyForInspection();
   void WorkerDestroyed();
   void WorkerVersionInstalled();
   void WorkerVersionDoomed();
@@ -81,21 +78,17 @@
   bool Matches(const ServiceWorkerContextCore* context, int64_t version_id);
 
  private:
-  enum WorkerState {
-    WORKER_UNINSPECTED,
-    WORKER_INSPECTED,
-    WORKER_TERMINATED,
-    WORKER_PAUSED_FOR_DEBUG_ON_START,
-    WORKER_READY_FOR_DEBUG_ON_START,
-    WORKER_PAUSED_FOR_REATTACH,
-  };
-
   ~ServiceWorkerDevToolsAgentHost() override;
 
   void AttachToWorker();
   void DetachFromWorker();
   void OnDispatchOnInspectorFrontend(const DevToolsMessageChunk& message);
 
+  enum WorkerState {
+    WORKER_NOT_READY,
+    WORKER_READY,
+    WORKER_TERMINATED,
+  };
   WorkerState state_;
   base::UnguessableToken devtools_worker_token_;
   int worker_process_id_;
diff --git a/content/browser/devtools/service_worker_devtools_manager.cc b/content/browser/devtools/service_worker_devtools_manager.cc
index c4541a3d..34d0f65 100644
--- a/content/browser/devtools/service_worker_devtools_manager.cc
+++ b/content/browser/devtools/service_worker_devtools_manager.cc
@@ -69,11 +69,13 @@
                                            url, scope, is_installed_version,
                                            *devtools_worker_token);
     live_hosts_[worker_id] = host;
-    for (auto& observer : observer_list_)
-      observer.WorkerCreated(host.get());
-    if (debug_service_worker_on_start_)
-      host->PauseForDebugOnStart();
-    *pause_on_start = host->IsPausedForDebugOnStart();
+    *pause_on_start = debug_service_worker_on_start_;
+    for (auto& observer : observer_list_) {
+      bool should_pause_on_start = false;
+      observer.WorkerCreated(host.get(), &should_pause_on_start);
+      if (should_pause_on_start)
+        *pause_on_start = true;
+    }
     return;
   }
 
@@ -81,8 +83,8 @@
   terminated_hosts_.erase(it);
   live_hosts_[worker_id] = agent_host;
   agent_host->WorkerRestarted(worker_process_id, worker_route_id);
-  *devtools_worker_token = agent_host->devtools_worker_token();
   *pause_on_start = agent_host->IsAttached();
+  *devtools_worker_token = agent_host->devtools_worker_token();
 }
 
 void ServiceWorkerDevToolsManager::WorkerReadyForInspection(
@@ -95,11 +97,8 @@
     return;
   scoped_refptr<ServiceWorkerDevToolsAgentHost> host = it->second;
   host->WorkerReadyForInspection();
-  for (auto& observer : observer_list_)
-    observer.WorkerReadyForInspection(host.get());
-
-  // Then bring up UI for the ones not picked by other clients.
-  if (host->IsPausedForDebugOnStart() && !host->IsAttached())
+  // Bring up UI for the ones not picked by other clients.
+  if (debug_service_worker_on_start_ && !host->IsAttached())
     host->Inspect();
 }
 
diff --git a/content/browser/devtools/service_worker_devtools_manager.h b/content/browser/devtools/service_worker_devtools_manager.h
index 38fd5cd..226180a0 100644
--- a/content/browser/devtools/service_worker_devtools_manager.h
+++ b/content/browser/devtools/service_worker_devtools_manager.h
@@ -35,9 +35,8 @@
  public:
   class Observer {
    public:
-    virtual void WorkerCreated(ServiceWorkerDevToolsAgentHost* host) {}
-    virtual void WorkerReadyForInspection(
-        ServiceWorkerDevToolsAgentHost* host) {}
+    virtual void WorkerCreated(ServiceWorkerDevToolsAgentHost* host,
+                               bool* should_pause_on_start) {}
     virtual void WorkerVersionInstalled(ServiceWorkerDevToolsAgentHost* host) {}
     virtual void WorkerVersionDoomed(ServiceWorkerDevToolsAgentHost* host) {}
     virtual void WorkerDestroyed(ServiceWorkerDevToolsAgentHost* host) {}
diff --git a/content/browser/devtools/shared_worker_devtools_agent_host.cc b/content/browser/devtools/shared_worker_devtools_agent_host.cc
index 931303a..10bd7e8e 100644
--- a/content/browser/devtools/shared_worker_devtools_agent_host.cc
+++ b/content/browser/devtools/shared_worker_devtools_agent_host.cc
@@ -22,6 +22,7 @@
     SharedWorkerHost* worker_host,
     const base::UnguessableToken& devtools_worker_token)
     : DevToolsAgentHostImpl(devtools_worker_token.ToString()),
+      state_(WORKER_NOT_READY),
       worker_host_(worker_host),
       devtools_worker_token_(devtools_worker_token),
       instance_(new SharedWorkerInstance(*worker_host->instance())) {
@@ -68,8 +69,8 @@
   session->AddHandler(std::make_unique<protocol::NetworkHandler>(GetId()));
   session->AddHandler(std::make_unique<protocol::SchemaHandler>());
   session->SetRenderer(GetProcess(), nullptr);
-  if (!waiting_ready_for_reattach_ && EnsureAgent())
-    session->AttachToAgent(agent_ptr_);
+  if (state_ == WORKER_READY)
+    session->AttachToAgent(EnsureAgent());
 }
 
 void SharedWorkerDevToolsAgentHost::DetachSession(int session_id) {
@@ -96,14 +97,11 @@
 }
 
 void SharedWorkerDevToolsAgentHost::WorkerReadyForInspection() {
+  DCHECK_EQ(WORKER_NOT_READY, state_);
   DCHECK(worker_host_);
-  if (!waiting_ready_for_reattach_)
-    return;
-  waiting_ready_for_reattach_ = false;
-  if (!EnsureAgent())
-    return;
+  state_ = WORKER_READY;
   for (DevToolsSession* session : sessions()) {
-    session->ReattachToAgent(agent_ptr_);
+    session->ReattachToAgent(EnsureAgent());
     for (const auto& pair : session->waiting_messages()) {
       int call_id = pair.first;
       const DevToolsSession::Message& message = pair.second;
@@ -113,18 +111,20 @@
   }
 }
 
-bool SharedWorkerDevToolsAgentHost::WorkerRestarted(
+void SharedWorkerDevToolsAgentHost::WorkerRestarted(
     SharedWorkerHost* worker_host) {
+  DCHECK_EQ(WORKER_TERMINATED, state_);
   DCHECK(!worker_host_);
+  state_ = WORKER_NOT_READY;
   worker_host_ = worker_host;
   for (DevToolsSession* session : sessions())
     session->SetRenderer(GetProcess(), nullptr);
-  waiting_ready_for_reattach_ = IsAttached();
-  return waiting_ready_for_reattach_;
 }
 
 void SharedWorkerDevToolsAgentHost::WorkerDestroyed() {
+  DCHECK_NE(WORKER_TERMINATED, state_);
   DCHECK(worker_host_);
+  state_ = WORKER_TERMINATED;
   for (auto* inspector : protocol::InspectorHandler::ForAgentHost(this))
     inspector->TargetCrashed();
   for (DevToolsSession* session : sessions())
@@ -138,12 +138,13 @@
                       : nullptr;
 }
 
-bool SharedWorkerDevToolsAgentHost::EnsureAgent() {
-  if (!worker_host_)
-    return false;
+const blink::mojom::DevToolsAgentAssociatedPtr&
+SharedWorkerDevToolsAgentHost::EnsureAgent() {
+  DCHECK_EQ(WORKER_READY, state_);
+  DCHECK(worker_host_);
   if (!agent_ptr_)
     worker_host_->GetDevToolsAgent(mojo::MakeRequest(&agent_ptr_));
-  return true;
+  return agent_ptr_;
 }
 
 }  // namespace content
diff --git a/content/browser/devtools/shared_worker_devtools_agent_host.h b/content/browser/devtools/shared_worker_devtools_agent_host.h
index d59ac31..3f7d2048 100644
--- a/content/browser/devtools/shared_worker_devtools_agent_host.h
+++ b/content/browser/devtools/shared_worker_devtools_agent_host.h
@@ -41,8 +41,7 @@
 
   bool Matches(SharedWorkerHost* worker_host);
   void WorkerReadyForInspection();
-  // Returns whether the worker should be paused for reattach.
-  bool WorkerRestarted(SharedWorkerHost* worker_host);
+  void WorkerRestarted(SharedWorkerHost* worker_host);
   void WorkerDestroyed();
 
   const base::UnguessableToken& devtools_worker_token() const {
@@ -50,17 +49,20 @@
   }
 
  private:
-  friend class SharedWorkerDevToolsManagerTest;
-
   ~SharedWorkerDevToolsAgentHost() override;
   RenderProcessHost* GetProcess();
-  bool EnsureAgent();
+  const blink::mojom::DevToolsAgentAssociatedPtr& EnsureAgent();
 
+  enum WorkerState {
+    WORKER_NOT_READY,
+    WORKER_READY,
+    WORKER_TERMINATED,
+  };
+  WorkerState state_;
   SharedWorkerHost* worker_host_;
   blink::mojom::DevToolsAgentAssociatedPtr agent_ptr_;
   base::UnguessableToken devtools_worker_token_;
   std::unique_ptr<SharedWorkerInstance> instance_;
-  bool waiting_ready_for_reattach_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(SharedWorkerDevToolsAgentHost);
 };
diff --git a/content/browser/devtools/shared_worker_devtools_manager.cc b/content/browser/devtools/shared_worker_devtools_manager.cc
index 779f122c..5731e4bb 100644
--- a/content/browser/devtools/shared_worker_devtools_manager.cc
+++ b/content/browser/devtools/shared_worker_devtools_manager.cc
@@ -45,7 +45,8 @@
   SharedWorkerDevToolsAgentHost* agent_host = *it;
   terminated_hosts_.erase(it);
   live_hosts_[worker_host] = agent_host;
-  *pause_on_start = agent_host->WorkerRestarted(worker_host);
+  agent_host->WorkerRestarted(worker_host);
+  *pause_on_start = agent_host->IsAttached();
   *devtools_worker_token = agent_host->devtools_worker_token();
 }
 
diff --git a/content/browser/devtools/shared_worker_devtools_manager.h b/content/browser/devtools/shared_worker_devtools_manager.h
index becbdd0..a937f44 100644
--- a/content/browser/devtools/shared_worker_devtools_manager.h
+++ b/content/browser/devtools/shared_worker_devtools_manager.h
@@ -28,6 +28,7 @@
 
   void AddAllAgentHosts(
       std::vector<scoped_refptr<SharedWorkerDevToolsAgentHost>>* result);
+  void AgentHostDestroyed(SharedWorkerDevToolsAgentHost* agent_host);
 
   void WorkerCreated(SharedWorkerHost* worker_host,
                      bool* pause_on_start,
@@ -37,14 +38,9 @@
 
  private:
   friend struct base::DefaultSingletonTraits<SharedWorkerDevToolsManager>;
-  friend class SharedWorkerDevToolsAgentHost;
-  friend class SharedWorkerDevToolsManagerTest;
-  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, BasicTest);
-  FRIEND_TEST_ALL_PREFIXES(SharedWorkerDevToolsManagerTest, AttachTest);
 
   SharedWorkerDevToolsManager();
   ~SharedWorkerDevToolsManager();
-  void AgentHostDestroyed(SharedWorkerDevToolsAgentHost* agent_host);
 
   // We retatin agent hosts as long as the shared worker is alive.
   std::map<SharedWorkerHost*, scoped_refptr<SharedWorkerDevToolsAgentHost>>
diff --git a/third_party/WebKit/Source/core/exported/WebDevToolsAgentImpl.cpp b/third_party/WebKit/Source/core/exported/WebDevToolsAgentImpl.cpp
index 7cdadf5..d19a928 100644
--- a/third_party/WebKit/Source/core/exported/WebDevToolsAgentImpl.cpp
+++ b/third_party/WebKit/Source/core/exported/WebDevToolsAgentImpl.cpp
@@ -533,7 +533,8 @@
   String state = saved_state;
   InspectorSession* session = InitializeSession(session_id, &state);
   session->Restore();
-  if (worker_client_)
+  // TODO(dgozman): use the optional instead of checking for empty.
+  if (worker_client_ && !state.IsEmpty())
     worker_client_->ResumeStartup();
 }
 
diff --git a/third_party/WebKit/Source/modules/exported/WebEmbeddedWorkerImpl.cpp b/third_party/WebKit/Source/modules/exported/WebEmbeddedWorkerImpl.cpp
index 42e3ddf..b2a3b36 100644
--- a/third_party/WebKit/Source/modules/exported/WebEmbeddedWorkerImpl.cpp
+++ b/third_party/WebKit/Source/modules/exported/WebEmbeddedWorkerImpl.cpp
@@ -208,7 +208,6 @@
   WebDevToolsAgentImpl* devtools_agent = shadow_page_->DevToolsAgent();
   if (devtools_agent)
     devtools_agent->Reattach(session_id, saved_state);
-  ResumeStartup();
 }
 
 void WebEmbeddedWorkerImpl::DetachDevTools(int session_id) {