Remove InterfaceRegistry/Provider from service workers

content/browser/service_worker/service_worker_version.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/service_worker_version.h"
 
 #include <stddef.h>
 
 #include <limits>
 #include <map>
@@ skipping 1460 matching lines @@
   DCHECK(!metrics_);
   DCHECK(start_worker_first_purpose_);
   metrics_.reset(new Metrics(this, start_worker_first_purpose_.value()));
 
   // We don't clear |start_worker_first_purpose_| here but clear in
   // FinishStartWorker. This is because StartWorkerInternal may be called
   // again from OnStoppedInternal if StopWorker is called before OnStarted.
 
   StartTimeoutTimer();
 
-  std::unique_ptr<EmbeddedWorkerStartParams> params(
-      new EmbeddedWorkerStartParams());
+  auto params = base::MakeUnique<EmbeddedWorkerStartParams>();
   params->service_worker_version_id = version_id_;
   params->scope = scope_;
   params->script_url = script_url_;
   params->is_installed = IsInstalled(status_);
   params->pause_after_download = pause_after_download_;
 
   embedded_worker_->Start(
-      std::move(params),
+      std::move(params), mojo::GetProxy(&event_dispatcher_),
       base::Bind(&ServiceWorkerVersion::OnStartSentAndScriptEvaluated,
                  weak_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerVersion::StartTimeoutTimer() {
   DCHECK(!timeout_timer_.IsRunning());
 
   if (embedded_worker_->devtools_attached()) {
     // Don't record the startup time metric once DevTools is attached.
     ClearTick(&start_time_);
@@ skipping 329 matching lines @@
   // TODO(kinuko): Consider if we want to add queue+resend mechanism here.
   IDMap<PendingRequest, IDMapOwnPointer>::iterator iter(&pending_requests_);
   while (!iter.IsAtEnd()) {
     TRACE_EVENT_ASYNC_END1("ServiceWorker", "ServiceWorkerVersion::Request",
                            iter.GetCurrentValue(), "Error", "Worker Stopped");
     iter.GetCurrentValue()->error_callback.Run(SERVICE_WORKER_ERROR_FAILED);
     iter.Advance();
   }
   pending_requests_.Clear();
   external_request_uuid_to_request_id_.clear();
-
-  // Close all mojo services. This will also fire and clear all callbacks
-  // for messages that are still outstanding for those services.
-  mojo_services_.clear();
+  event_dispatcher_.reset();
 
   // TODO(falken): Call SWURLRequestJob::ClearStream here?
   streaming_url_request_jobs_.clear();
 
   for (auto& observer : listeners_)
     observer.OnRunningStateChanged(this);
   if (should_restart) {
     StartWorkerInternal();
   } else if (!HasWork()) {
     for (auto& observer : listeners_)
       observer.OnNoWork(this);
   }
 }
 
-void ServiceWorkerVersion::OnMojoConnectionError(const char* service_name) {
-  // Simply deleting the service will cause error callbacks to be called from
-  // the destructor of the MojoServiceWrapper instance.
-  mojo_services_.erase(service_name);
-}
-
 void ServiceWorkerVersion::OnBeginEvent() {
   if (should_exclude_from_uma_ ||
       running_status() != EmbeddedWorkerStatus::RUNNING ||
       idle_time_.is_null()) {
     return;
   }
   ServiceWorkerMetrics::RecordTimeBetweenEvents(base::TimeTicks::Now() -
                                                 idle_time_);
 }
 
 void ServiceWorkerVersion::FinishStartWorker(ServiceWorkerStatusCode status) {
   start_worker_first_purpose_ = base::nullopt;
   RunCallbacks(this, &start_callbacks_, status);
 }
 
 void ServiceWorkerVersion::CleanUpExternalRequest(
     const std::string& request_uuid,
     ServiceWorkerStatusCode status) {
   if (status == SERVICE_WORKER_OK)
     return;
   external_request_uuid_to_request_id_.erase(request_uuid);
 }
 
 }  // namespace content