[DO NOT COMMIT] ServiceWorker: First touch of mojo

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 18 matching lines @@
 #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/service_worker/service_worker_status_code.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "ipc/ipc_message.h"
 #include "services/shell/public/cpp/interface_provider.h"
 #include "third_party/WebKit/public/platform/modules/serviceworker/WebServiceWorkerEventResult.h"
+#include "third_party/WebKit/public/platform/modules/serviceworker/service_worker_global_scope.mojom.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 // Windows headers will redefine SendMessage.
 #ifdef SendMessage
 #undef SendMessage
 #endif
 
 namespace net {
 class HttpResponseInfo;
@@ skipping 177 matching lines @@
   // 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);
 
+  template <typename Interface>
+  base::WeakPtr<Interface> GetMojoService();
+
+  template <typename Interface>
+  bool AddMojoService(mojo::InterfacePtr<Interface> interface,
+                      bool overwrite = false);
+
   // 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 94 matching lines @@
   void SetMainScriptHttpResponseInfo(const net::HttpResponseInfo& http_info);
   const net::HttpResponseInfo* GetMainScriptHttpResponseInfo();
 
   // Simulate ping timeout. Should be used for tests-only.
   void SimulatePingTimeoutForTesting();
 
   // Returns true if the service worker has work to do: it has pending
   // requests, in-progress streaming URLRequestJobs, or pending start callbacks.
   bool HasWork() const;
 
+  // Interfaces called from ServiceWorkerGlobalScopeHost
+  void OnSimpleEventResponse(int request_id,
+                             ServiceWorkerStatusCode result);
  private:
+  friend class ServiceWorkerGlobalScopeHostImpl;
   friend class base::RefCounted<ServiceWorkerVersion>;
   friend class ServiceWorkerMetrics;
   friend class ServiceWorkerReadFromCacheJobTest;
   friend class ServiceWorkerStallInStoppingTest;
   friend class ServiceWorkerURLRequestJobTest;
   friend class ServiceWorkerVersionBrowserTest;
   friend class ServiceWorkerVersionTest;
 
   FRIEND_TEST_ALL_PREFIXES(ServiceWorkerControlleeRequestHandlerTest,
                            ActivateWaitingVersion);
@@ skipping 373 matching lines @@
 
 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";
 
+  base::WeakPtr<Interface> interface = GetMojoService<Interface>();
+  request->mojo_service = Interface::Name_;
+  return interface;
+}
+
+template <typename Interface>
+base::WeakPtr<Interface> ServiceWorkerVersion::GetMojoService() {
+  DCHECK_EQ(EmbeddedWorkerStatus::RUNNING, running_status());
   MojoServiceWrapper<Interface>* service =
       static_cast<MojoServiceWrapper<Interface>*>(
           mojo_services_.get(Interface::Name_));
   if (!service) {
     mojo::InterfacePtr<Interface> interface;
     embedded_worker_->GetRemoteInterfaces()->GetInterface(&interface);
     interface.set_connection_error_handler(
         base::Bind(&ServiceWorkerVersion::OnMojoConnectionError,
                    weak_factory_.GetWeakPtr(), Interface::Name_));
     service = new MojoServiceWrapper<Interface>(this, std::move(interface));
     mojo_services_.add(Interface::Name_, base::WrapUnique(service));
   }
-  request->mojo_service = Interface::Name_;
   return service->GetWeakPtr();
 }
 
+template <typename Interface>
+bool ServiceWorkerVersion::AddMojoService(
+    mojo::InterfacePtr<Interface> interface, bool overwrite) {
+  LOG(ERROR) << __PRETTY_FUNCTION__;
+  // Fail if the interface is already registered.
+  if (!overwrite && mojo_services_.get(Interface::Name_)) {
+      return false;
+  }
+
+  interface.set_connection_error_handler(
+      base::Bind(&ServiceWorkerVersion::OnMojoConnectionError,
+                 weak_factory_.GetWeakPtr(), Interface::Name_));
+  MojoServiceWrapper<Interface>* service =
+      new MojoServiceWrapper<Interface>(this, std::move(interface));
+  mojo_services_.set(Interface::Name_, base::WrapUnique(service));
+  return true;
+}
+
+
 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,
     const ResponseCallbackType& callback) {
   PendingRequest* request = pending_requests_.Lookup(request_id);
   DCHECK(request) << "Invalid request id";
   DCHECK(!request->listener) << "Callback was already registered";
   DCHECK(!request->is_dispatched) << "Request already dispatched an IPC event";
   request->listener.reset(
       new EventResponseHandler<ResponseMessage, ResponseCallbackType>(
           embedded_worker()->AsWeakPtr(), request_id, callback));
 }
 
 template <typename ResponseMessage>
 void ServiceWorkerVersion::RegisterSimpleRequest(int request_id) {
   RegisterRequestCallback<ResponseMessage>(
       request_id,
-      base::Bind(&ServiceWorkerVersion::OnSimpleEventResponse, this));
+      base::Bind(static_cast<void(ServiceWorkerVersion::*)(int, blink::WebServiceWorkerEventResult)>(&ServiceWorkerVersion::OnSimpleEventResponse), this));
 }
 
 template <typename ResponseMessage, typename CallbackType>
 bool ServiceWorkerVersion::EventResponseHandler<ResponseMessage, CallbackType>::
     OnMessageReceived(const IPC::Message& message) {
   if (message.type() != ResponseMessage::ID)
     return false;
   int received_request_id;
   bool result = base::PickleIterator(message).ReadInt(&received_request_id);
   if (!result || received_request_id != request_id_)
     return false;
 
   CallbackType protect(callback_);
   // Essentially same code as what IPC_MESSAGE_FORWARD expands to.
   void* param = nullptr;
   if (!ResponseMessage::Dispatch(&message, &callback_, this, param,
                                  &CallbackType::Run))
     message.set_dispatch_error();
 
   // 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_