ServiceWorker: Add a check if error handler runs on the right thread

content/browser/service_worker/embedded_worker_instance.cc

 // Copyright 2013 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/service_worker/embedded_worker_instance.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/macros.h"
@@ skipping 103 matching lines @@
   // |rph| or its InterfaceProvider may be NULL in unit tests.
   if (!rph || !rph->GetRemoteInterfaces())
     return;
   mojom::EmbeddedWorkerSetupPtr setup;
   rph->GetRemoteInterfaces()->GetInterface(&setup);
   setup->ExchangeInterfaceProviders(
       thread_id, std::move(remote_interfaces),
       mojo::MakeProxy(std::move(exposed_interfaces)));
 }
 
+void CallDetach(EmbeddedWorkerInstance* instance) {

[nhiroki, 2016/11/02 08:42:39]

Just to confirm: A raw pointer is safe here because a callback bound with
CallDetach() is owned by EmbeddedWorkerInstance::client_ that has the same
lifetime with EmbeddedWorkerInstance.

[shimazu, 2016/11/04 01:09:21]

Done.

+  // This could be called on the UI thread if |client_| still be valid when the
+  // message loop on the UI thread gets destructed.
+  // TODO(shimazu): Remove this after https://crbug.com/604762 is fixed
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    DCHECK(ServiceWorkerUtils::IsMojoForServiceWorkerEnabled());
+    return;
+  }
+  instance->Detach();
+}
+
 }  // namespace
 
 // Lives on IO thread, proxies notifications to DevToolsManager that lives on
 // UI thread. Owned by EmbeddedWorkerInstance.
 class EmbeddedWorkerInstance::DevToolsProxy : public base::NonThreadSafe {
  public:
   DevToolsProxy(int process_id, int agent_route_id)
       : process_id_(process_id),
         agent_route_id_(agent_route_id) {}
 
@@ skipping 336 matching lines @@
 
   params->embedded_worker_id = embedded_worker_id_;
   params->worker_devtools_agent_route_id = MSG_ROUTING_NONE;
   params->wait_for_debugger = false;
   params->settings.v8_cache_options = GetV8CacheOptions();
 
   mojom::EmbeddedWorkerInstanceClientRequest request;
   if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled()) {
     request = mojo::GetProxy(&client_);
     client_.set_connection_error_handler(
-        base::Bind(&EmbeddedWorkerInstance::Detach, base::Unretained(this)));
+        base::Bind(&CallDetach, base::Unretained(this)));
   }
 
   inflight_start_task_.reset(
       new StartTask(this, params->script_url, std::move(request)));
   inflight_start_task_->Start(std::move(params), callback);
 }
 
 ServiceWorkerStatusCode EmbeddedWorkerInstance::Stop() {
   DCHECK(status_ == EmbeddedWorkerStatus::STARTING ||
          status_ == EmbeddedWorkerStatus::RUNNING)
@@ skipping 481 matching lines @@
     case SCRIPT_READ_FINISHED:
       return "Script read finished";
     case STARTING_PHASE_MAX_VALUE:
       NOTREACHED();
   }
   NOTREACHED() << phase;
   return std::string();
 }
 
 }  // namespace content