Move content/renderer/background_sync to Blink

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"
@@ skipping 22 matching lines @@
 #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_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/InterfaceRegistry.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/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"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
@@ skipping 110 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 NavigationPreloadRequestsMap =
       IDMap<ServiceWorkerContextClient::NavigationPreloadRequest,
             IDMapOwnPointer>;
 
   explicit WorkerContextData(ServiceWorkerContextClient* owner)
       : interface_registry(std::string()),
         weak_factory(owner),
-        proxy_weak_factory(owner->proxy_) {}
+        proxy_weak_factory(owner->proxy_) {
+    blink_interface_registry.reset(
+        new BlinkInterfaceRegistryImpl(interface_registry.GetWeakPtr()));
+  }
 
   ~WorkerContextData() {
     DCHECK(thread_checker.CalledOnValidThread());
   }
 
   // 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;
 
+  std::unique_ptr<blink::InterfaceRegistry> blink_interface_registry;
+
   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 155 matching lines @@
     int worker_devtools_agent_route_id,
     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),
-      embedded_worker_client_(std::move(embedded_worker_client)) {
+      embedded_worker_client_(std::move(embedded_worker_client)),
+      blink_interface_registry_(nullptr) {
   TRACE_EVENT_ASYNC_BEGIN0("ServiceWorker",
                            "ServiceWorkerContextClient::StartingWorkerContext",
                            this);
   TRACE_EVENT_ASYNC_STEP_INTO0(
       "ServiceWorker",
       "ServiceWorkerContextClient::StartingWorkerContext",
       this,
       "PrepareWorker");
 }
 
@@ skipping 136 matching lines @@
 
   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);
   }
 
   SetRegistrationInServiceWorkerGlobalScope(registration_info, version_attrs);
 
@@ skipping 28 matching lines @@
           context, service_worker_version_id_, script_url_);
 }
 
 void ServiceWorkerContextClient::willDestroyWorkerContext(
     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());
-  }
   // 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.
   context_.reset();
@@ skipping 170 matching lines @@
 
 void ServiceWorkerContextClient::didHandlePushEvent(
     int request_id,
     blink::WebServiceWorkerEventResult result,
     double event_dispatch_time) {
   Send(new ServiceWorkerHostMsg_PushEventFinished(
       GetRoutingID(), request_id, result,
       base::Time::FromDoubleT(event_dispatch_time)));
 }
 
-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,
-                  base::Time::FromDoubleT(event_dispatch_time));
-  } else {
-    callback->Run(blink::mojom::ServiceWorkerEventStatus::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());
 
   // Create a content::ServiceWorkerNetworkProvider for this data source so
   // we can observe its requests.
   std::unique_ptr<ServiceWorkerNetworkProvider> provider =
       base::MakeUnique<ServiceWorkerNetworkProvider>(
           MSG_ROUTING_NONE, SERVICE_WORKER_PROVIDER_FOR_CONTROLLER,
@@ skipping 85 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) {
-  TRACE_EVENT0("ServiceWorker",
-               "ServiceWorkerContextClient::DispatchSyncEvent");
-  int request_id =
-      context_->sync_event_callbacks.Add(new SyncCallback(callback));
-
-  // TODO(jkarlin): Make this blink::WebString::FromUTF8Lenient once
-  // https://crrev.com/1768063002/ lands.
-  proxy_->dispatchSyncEvent(request_id, blink::WebString::fromUTF8(tag),
-                            last_chance);
+blink::InterfaceRegistry* ServiceWorkerContextClient::interfaceRegistry() {
+  return context_->blink_interface_registry.get();
 }
 
 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 348 matching lines @@
 }
 
 base::WeakPtr<ServiceWorkerContextClient>
 ServiceWorkerContextClient::GetWeakPtr() {
   DCHECK(worker_task_runner_->RunsTasksOnCurrentThread());
   DCHECK(context_);
   return context_->weak_factory.GetWeakPtr();
 }
 
 }  // namespace content