Remove InterfaceRegistry/Provider from service workers

content/renderer/service_worker/service_worker_context_client.cc

 // Copyright 2015 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/renderer/service_worker/service_worker_context_client.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
+#include "content/child/background_sync/background_sync_type_converters.h"
 #include "content/child/notifications/notification_data_conversions.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/service_worker/service_worker_dispatcher.h"
 #include "content/child/service_worker/service_worker_handle_reference.h"
 #include "content/child/service_worker/service_worker_network_provider.h"
 #include "content/child/service_worker/service_worker_provider_context.h"
 #include "content/child/service_worker/service_worker_registration_handle_reference.h"
 #include "content/child/service_worker/web_service_worker_impl.h"
 #include "content/child/service_worker/web_service_worker_provider_impl.h"
 #include "content/child/service_worker/web_service_worker_registration_impl.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/child/web_data_consumer_handle_impl.h"
 #include "content/child/webmessageportchannel_impl.h"
 #include "content/common/devtools_messages.h"
 #include "content/common/message_port_messages.h"
 #include "content/common/service_worker/embedded_worker_messages.h"
-#include "content/common/service_worker/fetch_event_dispatcher.mojom.h"
+#include "content/common/service_worker/service_worker_event_dispatcher.mojom.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/common/push_event_payload.h"
 #include "content/public/common/referrer.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/document_state.h"
-#include "content/renderer/background_sync/background_sync_client_impl.h"
 #include "content/renderer/devtools/devtools_agent.h"
 #include "content/renderer/render_thread_impl.h"
 #include "content/renderer/service_worker/embedded_worker_dispatcher.h"
 #include "content/renderer/service_worker/embedded_worker_instance_client_impl.h"
 #include "content/renderer/service_worker/service_worker_type_util.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
-#include "mojo/public/cpp/bindings/interface_request.h"
-#include "mojo/public/cpp/bindings/strong_binding.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
-#include "services/service_manager/public/cpp/interface_registry.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebMessagePortChannel.h"
 #include "third_party/WebKit/public/platform/WebReferrerPolicy.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/modules/background_sync/WebSyncRegistration.h"
 #include "third_party/WebKit/public/platform/modules/notifications/WebNotificationData.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerClientQueryOptions.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerError.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
@@ skipping 111 matching lines @@
 // worker thread.
 struct ServiceWorkerContextClient::WorkerContextData {
   using ClientsCallbacksMap =
       IDMap<blink::WebServiceWorkerClientsCallbacks, IDMapOwnPointer>;
   using ClaimClientsCallbacksMap =
       IDMap<blink::WebServiceWorkerClientsClaimCallbacks, IDMapOwnPointer>;
   using ClientCallbacksMap =
       IDMap<blink::WebServiceWorkerClientCallbacks, IDMapOwnPointer>;
   using SkipWaitingCallbacksMap =
       IDMap<blink::WebServiceWorkerSkipWaitingCallbacks, IDMapOwnPointer>;
-  using SyncEventCallbacksMap =
-      IDMap<const base::Callback<void(blink::mojom::ServiceWorkerEventStatus,
-                                      base::Time /* dispatch_event_time */)>,
-            IDMapOwnPointer>;
-  using FetchEventCallbacksMap =
-      IDMap<const base::Callback<void(ServiceWorkerStatusCode,
-                                      base::Time /* dispatch_event_time */)>,
-            IDMapOwnPointer>;
+  using SyncEventCallbacksMap = IDMap<const SyncCallback, IDMapOwnPointer>;
+  using FetchEventCallbacksMap = IDMap<const FetchCallback, IDMapOwnPointer>;
   using NavigationPreloadRequestsMap =
       IDMap<ServiceWorkerContextClient::NavigationPreloadRequest,
             IDMapOwnPointer>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
-      : interface_registry(std::string()),
+      : event_dispatcher_binding(owner),
         weak_factory(owner),
         proxy_weak_factory(owner->proxy_) {}
 
   ~WorkerContextData() {
     DCHECK(thread_checker.CalledOnValidThread());
   }
 
+  mojo::Binding<mojom::ServiceWorkerEventDispatcher> event_dispatcher_binding;
+
   // Pending callbacks for GetClientDocuments().
   ClientsCallbacksMap clients_callbacks;
 
   // Pending callbacks for OpenWindow() and FocusClient().
   ClientCallbacksMap client_callbacks;
 
   // Pending callbacks for SkipWaiting().
   SkipWaitingCallbacksMap skip_waiting_callbacks;
 
   // Pending callbacks for ClaimClients().
   ClaimClientsCallbacksMap claim_clients_callbacks;
 
   // Pending callbacks for Background Sync Events.
   SyncEventCallbacksMap sync_event_callbacks;
 
   // Pending callbacks for Fetch Events.
   FetchEventCallbacksMap fetch_event_callbacks;
 
   // Pending navigation preload requests.
   NavigationPreloadRequestsMap preload_requests;
 
-  service_manager::InterfaceRegistry interface_registry;
-  // This is not used when mojo for the service workers is enabled. At that
-  // time, remote interfaces are stored in EmbeddedWorkerInstanceClientImpl.
-  service_manager::InterfaceProvider remote_interfaces;
-
   base::ThreadChecker thread_checker;
   base::WeakPtrFactory<ServiceWorkerContextClient> weak_factory;
   base::WeakPtrFactory<blink::WebServiceWorkerContextProxy> proxy_weak_factory;
 };
 
 class ServiceWorkerContextClient::NavigationPreloadRequest final
     : public mojom::URLLoaderClient {
  public:
   NavigationPreloadRequest(int fetch_event_id,
                            const GURL& url,
@@ skipping 85 matching lines @@
   const int fetch_event_id_;
   const GURL url_;
   mojom::URLLoaderPtr url_loader_;
   mojo::Binding<mojom::URLLoaderClient> binding_;
 
   std::unique_ptr<blink::WebServiceWorkerResponse> response_;
   mojo::ScopedDataPipeConsumerHandle body_;
   bool result_reported_ = false;
 };
 
-class ServiceWorkerContextClient::FetchEventDispatcherImpl
-    : public NON_EXPORTED_BASE(mojom::FetchEventDispatcher) {
- public:
-  static void Create(mojom::FetchEventDispatcherRequest request) {
-    mojo::MakeStrongBinding(base::MakeUnique<FetchEventDispatcherImpl>(),
-                            std::move(request));
-  }
-
-  FetchEventDispatcherImpl() {}
-
-  ~FetchEventDispatcherImpl() override {}
-
-  void DispatchFetchEvent(int fetch_event_id,
-                          const ServiceWorkerFetchRequest& request,
-                          mojom::FetchEventPreloadHandlePtr preload_handle,
-                          const DispatchFetchEventCallback& callback) override {
-    ServiceWorkerContextClient* client =
-        ServiceWorkerContextClient::ThreadSpecificInstance();
-    if (!client) {
-      callback.Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
-      return;
-    }
-    client->DispatchFetchEvent(
-        fetch_event_id, request,
-        preload_handle
-            ? base::MakeUnique<NavigationPreloadRequest>(
-                  fetch_event_id, request.url, std::move(preload_handle))
-            : nullptr,
-        callback);
-  }
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(FetchEventDispatcherImpl);
-};
-
 ServiceWorkerContextClient*
 ServiceWorkerContextClient::ThreadSpecificInstance() {
   return g_worker_client_tls.Pointer()->Get();
 }
 
 ServiceWorkerContextClient::ServiceWorkerContextClient(
     int embedded_worker_id,
     int64_t service_worker_version_id,
     const GURL& service_worker_scope,
     const GURL& script_url,
     int worker_devtools_agent_route_id,
+    mojom::ServiceWorkerEventDispatcherRequest dispatcher_request,
     std::unique_ptr<EmbeddedWorkerInstanceClientImpl> embedded_worker_client)
     : embedded_worker_id_(embedded_worker_id),
       service_worker_version_id_(service_worker_version_id),
       service_worker_scope_(service_worker_scope),
       script_url_(script_url),
       worker_devtools_agent_route_id_(worker_devtools_agent_route_id),
       sender_(ChildThreadImpl::current()->thread_safe_sender()),
       main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       proxy_(nullptr),
+      pending_dispatcher_request_(std::move(dispatcher_request)),
       embedded_worker_client_(std::move(embedded_worker_client)) {
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerContextClient::StartingWorkerContext",
                            this);
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerContextClient::StartingWorkerContext",
       this,
       "PrepareWorker");
 }
 
+ServiceWorkerContextClient::ServiceWorkerContextClient(
+    int embedded_worker_id,
+    int64_t service_worker_version_id,
+    const GURL& service_worker_scope,
+    const GURL& script_url,
+    int worker_devtools_agent_route_id)
+    : ServiceWorkerContextClient::ServiceWorkerContextClient(
+          embedded_worker_id,
+          service_worker_version_id,
+          service_worker_scope,
+          script_url,
+          worker_devtools_agent_route_id,
+          mojom::ServiceWorkerEventDispatcherRequest(),
+          nullptr) {}
+
 ServiceWorkerContextClient::~ServiceWorkerContextClient() {}
 
 void ServiceWorkerContextClient::OnMessageReceived(
     int thread_id,
     int embedded_worker_id,
     const IPC::Message& message) {
   CHECK_EQ(embedded_worker_id_, embedded_worker_id);
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(ServiceWorkerContextClient, message)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ActivateEvent, OnActivateEvent)
@@ skipping 19 matching lines @@
                         OnNavigateClientError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidSkipWaiting, OnDidSkipWaiting)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_DidClaimClients, OnDidClaimClients)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_ClaimClientsError, OnClaimClientsError)
     IPC_MESSAGE_HANDLER(ServiceWorkerMsg_Ping, OnPing);
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled);
 }
 
-void ServiceWorkerContextClient::BindInterfaceProviders(
-    service_manager::mojom::InterfaceProviderRequest request,
-    service_manager::mojom::InterfaceProviderPtr remote_interfaces) {
-  context_->interface_registry.Bind(
-      std::move(request), service_manager::Identity(),
-      service_manager::InterfaceProviderSpec(), service_manager::Identity(),
-      service_manager::InterfaceProviderSpec());
-  context_->remote_interfaces.Bind(std::move(remote_interfaces));
-}
-
 blink::WebURL ServiceWorkerContextClient::scope() const {
   return service_worker_scope_;
 }
 
 void ServiceWorkerContextClient::getClient(
     const blink::WebString& id,
     blink::WebServiceWorkerClientCallbacks* callbacks) {
   DCHECK(callbacks);
   int request_id = context_->client_callbacks.Add(callbacks);
   Send(new ServiceWorkerHostMsg_GetClient(
@@ skipping 75 matching lines @@
   // willDestroyWorkerContext.
   context_.reset(new WorkerContextData(this));
 
   ServiceWorkerRegistrationObjectInfo registration_info;
   ServiceWorkerVersionAttributes version_attrs;
   provider_context_->GetAssociatedRegistration(&registration_info,
                                                &version_attrs);
   DCHECK_NE(registration_info.registration_id,
             kInvalidServiceWorkerRegistrationId);
 
-  // Register Mojo interfaces.
-  context_->interface_registry.AddInterface(
-      base::Bind(&BackgroundSyncClientImpl::Create));
-  context_->interface_registry.AddInterface(
-      base::Bind(&FetchEventDispatcherImpl::Create));
-
   if (ServiceWorkerUtils::IsMojoForServiceWorkerEnabled()) {
-    DCHECK(embedded_worker_client_);
-    embedded_worker_client_->ExposeInterfacesToBrowser(
-        &context_->interface_registry);
+    DCHECK(pending_dispatcher_request_.is_pending());
+    BindEventDispatcher(std::move(pending_dispatcher_request_));
   }
 
   SetRegistrationInServiceWorkerGlobalScope(registration_info, version_attrs);
 
   Send(new EmbeddedWorkerHostMsg_WorkerThreadStarted(
       embedded_worker_id_, WorkerThread::GetCurrentId(),
       provider_context_->provider_id()));
 
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
@@ skipping 26 matching lines @@
     v8::Local<v8::Context> context) {
   // At this point WillStopCurrentWorkerThread is already called, so
   // worker_task_runner_->RunsTasksOnCurrentThread() returns false
   // (while we're still on the worker thread).
   proxy_ = NULL;
 
   // Aborts the all pending sync event callbacks.
   for (WorkerContextData::SyncEventCallbacksMap::iterator it(
            &context_->sync_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
-    it.GetCurrentValue()->Run(blink::mojom::ServiceWorkerEventStatus::ABORTED,
-                              base::Time::Now());
+    it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
   // Aborts the all pending fetch event callbacks.
   for (WorkerContextData::FetchEventCallbacksMap::iterator it(
            &context_->fetch_event_callbacks);
        !it.IsAtEnd(); it.Advance()) {
     it.GetCurrentValue()->Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
 
   // We have to clear callbacks now, as they need to be freed on the
   // same thread.
@@ skipping 180 matching lines @@
 
 void ServiceWorkerContextClient::didHandleSyncEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   const SyncCallback* callback =
       context_->sync_event_callbacks.Lookup(request_id);
   if (!callback)
     return;
   if (result == blink::WebServiceWorkerEventResultCompleted) {
-    callback->Run(blink::mojom::ServiceWorkerEventStatus::COMPLETED,
+    callback->Run(SERVICE_WORKER_OK,
                   base::Time::FromDoubleT(event_dispatch_time));
   } else {
-    callback->Run(blink::mojom::ServiceWorkerEventStatus::REJECTED,
+    callback->Run(SERVICE_WORKER_ERROR_EVENT_WAITUNTIL_REJECTED,
                   base::Time::FromDoubleT(event_dispatch_time));
   }
   context_->sync_event_callbacks.Remove(request_id);
 }
 
 blink::WebServiceWorkerNetworkProvider*
 ServiceWorkerContextClient::createServiceWorkerNetworkProvider(
     blink::WebDataSource* data_source) {
   DCHECK(main_thread_task_runner_->RunsTasksOnCurrentThread());
 
@@ skipping 92 matching lines @@
 void ServiceWorkerContextClient::registerForeignFetchScopes(
     const blink::WebVector<blink::WebURL>& sub_scopes,
     const blink::WebVector<blink::WebSecurityOrigin>& origins) {
   Send(new ServiceWorkerHostMsg_RegisterForeignFetchScopes(
       GetRoutingID(), std::vector<GURL>(sub_scopes.begin(), sub_scopes.end()),
       std::vector<url::Origin>(origins.begin(), origins.end())));
 }
 
 void ServiceWorkerContextClient::DispatchSyncEvent(
     const std::string& tag,
-    blink::WebServiceWorkerContextProxy::LastChanceOption last_chance,
-    const SyncCallback& callback) {
+    blink::mojom::BackgroundSyncEventLastChance last_chance,
+    const DispatchSyncEventCallback& callback) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchSyncEvent");
   int request_id =
       context_->sync_event_callbacks.Add(new SyncCallback(callback));
 
+  blink::WebServiceWorkerContextProxy::LastChanceOption web_last_chance =
+      mojo::ConvertTo<blink::WebServiceWorkerContextProxy::LastChanceOption>(

[dcheng, 2016/11/22 07:59:04]

Is it possible to typemap this?

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

I don't think so because blink types aren't available in content/browser. I'll
do that when I move these functions to blink-side.

Added TODO for now.

+          last_chance);
+
   // TODO(jkarlin): Make this blink::WebString::FromUTF8Lenient once
   // https://crrev.com/1768063002/ lands.
   proxy_->dispatchSyncEvent(request_id, blink::WebString::fromUTF8(tag),
-                            last_chance);
+                            web_last_chance);
 }
 
 void ServiceWorkerContextClient::Send(IPC::Message* message) {
   sender_->Send(message);
 }
 
 void ServiceWorkerContextClient::SendWorkerStarted() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   TRACE_EVENT_ASYNC_END0("ServiceWorker",
                          "ServiceWorkerContextClient::StartingWorkerContext",
@@ skipping 57 matching lines @@
 
 void ServiceWorkerContextClient::OnInstallEvent(int request_id) {
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::OnInstallEvent");
   proxy_->dispatchInstallEvent(request_id);
 }
 
 void ServiceWorkerContextClient::DispatchFetchEvent(
     int fetch_event_id,
     const ServiceWorkerFetchRequest& request,
-    std::unique_ptr<NavigationPreloadRequest> preload_request,
-    const FetchCallback& callback) {
+    mojom::FetchEventPreloadHandlePtr preload_handle,
+    const DispatchFetchEventCallback& callback) {
+  std::unique_ptr<NavigationPreloadRequest> preload_request =
+      preload_handle
+          ? base::MakeUnique<NavigationPreloadRequest>(
+                fetch_event_id, request.url, std::move(preload_handle))
+          : nullptr;
   const bool navigation_preload_sent = !!preload_request;
   blink::WebServiceWorkerRequest webRequest;
   TRACE_EVENT0("ServiceWorker",
                "ServiceWorkerContextClient::DispatchFetchEvent");
   context_->fetch_event_callbacks.AddWithID(new FetchCallback(callback),
                                             fetch_event_id);
   if (preload_request) {
     context_->preload_requests.AddWithID(std::move(preload_request),
                                          fetch_event_id);
   }
@@ skipping 261 matching lines @@
   proxy_->onNavigationPreloadResponse(fetch_event_id, std::move(response),
                                       std::move(data_consumer_handle));
 }
 
 void ServiceWorkerContextClient::OnNavigationPreloadError(
     int fetch_event_id,
     std::unique_ptr<blink::WebServiceWorkerError> error) {
   proxy_->onNavigationPreloadError(fetch_event_id, std::move(error));
 }
 
+void ServiceWorkerContextClient::BindEventDispatcher(
+    mojom::ServiceWorkerEventDispatcherRequest request) {
+  DCHECK(context_);
+  DCHECK(!context_->event_dispatcher_binding.is_bound());
+  context_->event_dispatcher_binding.Bind(std::move(request));
+}
+
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content