Remove InterfaceRegistry/Provider from service workers

content/browser/service_worker/service_worker_version.h

 // 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.
 
 #ifndef CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 #define CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_
 
 #include <stdint.h>
 
 #include <functional>
@@ skipping 16 matching lines @@
 #include "base/optional.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "content/browser/service_worker/embedded_worker_instance.h"
 #include "content/browser/service_worker/embedded_worker_status.h"
 #include "content/browser/service_worker/service_worker_metrics.h"
 #include "content/browser/service_worker/service_worker_script_cache_map.h"
 #include "content/common/content_export.h"
 #include "content/common/origin_trials/trial_token_validator.h"
+#include "content/common/service_worker/service_worker_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "ipc/ipc_message.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerEventResult.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 // Windows headers will redefine SendMessage.
@@ skipping 213 matching lines @@
   // TODO(mek): Use something other than a bool for event status.
   bool FinishRequest(int request_id,
                      bool was_handled,
                      base::Time dispatch_event_time);
 
   // Finishes an external request that was started by StartExternalRequest().
   // Returns false if there was an error finishing the request: e.g. the request
   // was not found or the worker already terminated.
   bool FinishExternalRequest(const std::string& request_uuid);
 
-  // Connects to a specific mojo service exposed by the (running) service
-  // worker. If a connection to a service for the same Interface already exists
-  // this will return that existing connection. The |request_id| must be a value
-  // previously returned by StartRequest. If the connection to the service
-  // fails or closes before the request finished, the error callback associated
-  // with |request_id| is called.
-  // Only call GetMojoServiceForRequest once for a specific |request_id|.
-  template <typename Interface>
-  base::WeakPtr<Interface> GetMojoServiceForRequest(int request_id);
+  // The dispatcher should be valid after the worker is started and invalid
+  // after StopWorker or OnDetached is called.

[falken, 2016/11/23 14:32:31]

nit: the "should be" makes it unclear whether this comment is normative or
descriptive. Maybe s/should be/is/. But what does the function do when called
when it's invalid? Does it DCHECK in line 274? If so maybe the comment should
just say "This function can only be called when the worker is RUNNING." similar
to DispatchEvent below.

[shimazu, 2016/11/24 06:47:32]

Thanks, that's right.
Updated.

+  mojom::ServiceWorkerEventDispatcher* event_dispatcher() {
+    DCHECK(event_dispatcher_.is_bound());
+    return event_dispatcher_.get();
+  }
 
   // Dispatches an event. If dispatching the event fails, all of the error
   // callbacks that were associated with |request_ids| via StartRequest are
   // called.
   // Use RegisterRequestCallback or RegisterSimpleRequest to register a callback
   // to receive messages sent back in response to this event before calling this
   // method.
   // This must be called when the worker is running.
   void DispatchEvent(const std::vector<int>& request_ids,
                      const IPC::Message& message);
@@ skipping 459 matching lines @@
 
   // Holds in-flight requests, including requests due to outstanding push,
   // fetch, sync, etc. events.
   IDMap<PendingRequest, IDMapOwnPointer> pending_requests_;
 
   // Container for pending external requests for this service worker.
   // (key, value): (request uuid, request id).
   using RequestUUIDToRequestIDMap = std::map<std::string, int>;
   RequestUUIDToRequestIDMap external_request_uuid_to_request_id_;
 
-  // Stores all open connections to mojo services. Maps the service name to
-  // the actual interface pointer. When a connection is closed it is removed
-  // from this map.
-  // mojo_services_[Interface::Name_] is assumed to always contain a
-  // MojoServiceWrapper<Interface> instance.
-  base::ScopedPtrHashMap<const char*, std::unique_ptr<BaseMojoServiceWrapper>>
-      mojo_services_;
+  // Connected to ServiceWorkerContextClient while the worker is running.
+  mojom::ServiceWorkerEventDispatcherPtr event_dispatcher_;
 
   std::set<const ServiceWorkerURLRequestJob*> streaming_url_request_jobs_;
 
   std::map<std::string, ServiceWorkerProviderHost*> controllee_map_;
   // Will be null while shutting down.
   base::WeakPtr<ServiceWorkerContextCore> context_;
   base::ObserverList<Listener> listeners_;
   ServiceWorkerScriptCacheMap script_cache_map_;
   base::OneShotTimer update_timer_;
 
@@ skipping 42 matching lines @@
 
   // Keeps the first purpose of starting the worker for UMA. Cleared in
   // FinishStartWorker().
   base::Optional<ServiceWorkerMetrics::EventType> start_worker_first_purpose_;
 
   base::WeakPtrFactory<ServiceWorkerVersion> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerVersion);
 };
 
-template <typename Interface>
-base::WeakPtr<Interface> ServiceWorkerVersion::GetMojoServiceForRequest(
-    int request_id) {
-  DCHECK_EQ(EmbeddedWorkerStatus::RUNNING, running_status());
-  PendingRequest* request = pending_requests_.Lookup(request_id);
-  DCHECK(request) << "Invalid request id";
-  DCHECK(!request->mojo_service)
-      << "Request is already associated with a mojo service";
-
-  MojoServiceWrapper<Interface>* service =
-      static_cast<MojoServiceWrapper<Interface>*>(
-          mojo_services_.get(Interface::Name_));
-  if (!service) {
-    mojo::InterfacePtr<Interface> interface_ptr;
-    embedded_worker_->GetRemoteInterfaces()->GetInterface(&interface_ptr);
-    interface_ptr.set_connection_error_handler(
-        base::Bind(&ServiceWorkerVersion::OnMojoConnectionError,
-                   weak_factory_.GetWeakPtr(), Interface::Name_));
-    service = new MojoServiceWrapper<Interface>(this, std::move(interface_ptr));
-    mojo_services_.add(Interface::Name_, base::WrapUnique(service));
-  }
-  request->mojo_service = Interface::Name_;
-  return service->GetWeakPtr();
-}
-
 template <typename ResponseMessage>
 void ServiceWorkerVersion::DispatchSimpleEvent(int request_id,
                                                const IPC::Message& message) {
   RegisterSimpleRequest<ResponseMessage>(request_id);
   DispatchEvent({request_id}, message);
 }
 
 template <typename ResponseMessage, typename ResponseCallbackType>
 void ServiceWorkerVersion::RegisterRequestCallback(
     int request_id,
@@ skipping 33 matching lines @@
 
   // At this point |this| can have been deleted, so don't do anything other
   // than returning.
 
   return true;
 }
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_SERVICE_WORKER_SERVICE_WORKER_VERSION_H_