[DO NOT COMMIT] ServiceWorker: First touch of mojo

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeClientImpl.cpp

 /*
  * Copyright (C) 2014 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "web/ServiceWorkerGlobalScopeClientImpl.h"
 
 #include "modules/fetch/Response.h"
+#include "modules/serviceworkers/FetchEvent.h"
+#include "modules/serviceworkers/ForeignFetchEvent.h"
+#include "modules/serviceworkers/WaitUntilObserver.h"
+#include "platform/heap/ThreadState.h"
+#include "public/platform/ServiceRegistry.h"
 #include "public/platform/WebURL.h"
+#include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "public/web/modules/serviceworker/WebServiceWorkerContextClient.h"
 #include <memory>
 
+namespace {
+void printIsMainThread_internal(const char* pretty_function, int line) {
+  LOG(ERROR) << "[" << pretty_function << ":" << line << "] "
+             << ((blink::ThreadState::current()->isMainThread()) ? "true" : "false");
+}
+}
+#define printIsMainThread() printIsMainThread_internal(__PRETTY_FUNCTION__, __LINE__)
+#define cerrWithHeader() LOG(ERROR) << "[" << __PRETTY_FUNCTION__ << ":" << __LINE__ << "] "
+
+
 namespace blink {
 
 ServiceWorkerGlobalScopeClient* ServiceWorkerGlobalScopeClientImpl::create(WebServiceWorkerContextClient& client)
 {
+    printIsMainThread();
     return new ServiceWorkerGlobalScopeClientImpl(client);
 }
 
 ServiceWorkerGlobalScopeClientImpl::~ServiceWorkerGlobalScopeClientImpl()
 {
+    printIsMainThread();
+}
+
+void ServiceWorkerGlobalScopeClientImpl::dispose()
+{
+    printIsMainThread();
+    m_clientBinding->Close();
+    m_hostProcess.reset();
 }
 
 void ServiceWorkerGlobalScopeClientImpl::getClient(const WebString& id, WebServiceWorkerClientCallbacks* callbacks)
 {
     m_client.getClient(id, callbacks);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::getClients(const WebServiceWorkerClientQueryOptions& options, WebServiceWorkerClientsCallbacks* callbacks)
 {
     m_client.getClients(options, callbacks);
@@ skipping 12 matching lines @@
 void ServiceWorkerGlobalScopeClientImpl::clearCachedMetadata(const WebURL& url)
 {
     m_client.clearCachedMetadata(url);
 }
 
 WebURL ServiceWorkerGlobalScopeClientImpl::scope() const
 {
     return m_client.scope();
 }
 
+void ServiceWorkerGlobalScopeClientImpl::didInitializeContext(ServiceWorkerGlobalScope* parent) {
+    // This should be reclaimed on the worker thread
+    ThreadState::current()->registerPreFinalizer(this);
+    printIsMainThread();
+    m_parent = parent;
+    m_clientBinding.reset(new mojo::Binding<mojom::blink::ServiceWorkerGlobalScopeClient>(this));
+    m_client.serviceRegistry()->connectToRemoteService(mojo::GetProxy(&m_hostProcess));
+    m_hostProcess->SetClient(m_clientBinding->CreateInterfacePtrAndBind());
+}
+
 void ServiceWorkerGlobalScopeClientImpl::didHandleActivateEvent(int eventID, WebServiceWorkerEventResult result)
 {
     m_client.didHandleActivateEvent(eventID, result);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::didHandleExtendableMessageEvent(int eventID, WebServiceWorkerEventResult result)
 {
     m_client.didHandleExtendableMessageEvent(eventID, result);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::respondToFetchEvent(int responseID)
 {
+  if (m_fetchCallbacks.contains(responseID)) {
+    LOG(ERROR) << "MOJOMOJOMOJO respond: fallback";
+    auto callback = m_fetchCallbacks.take(responseID);
+    callback.Run(false, nullptr);
+    return;
+  }
+
     m_client.respondToFetchEvent(responseID);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::respondToFetchEvent(int responseID, const WebServiceWorkerResponse& response)
 {
-    m_client.respondToFetchEvent(responseID, response);
+  if (m_fetchCallbacks.contains(responseID)) {
+    LOG(ERROR) << "MOJOMOJOMOJO respond: response";
+    auto callback = m_fetchCallbacks.take(responseID);
+    auto mojoResponse = mojom::blink::ServiceWorkerResponse::New();
+    mojoResponse->url = response.url().string();
+    mojoResponse->status_code = response.status();
+    mojoResponse->status_text = response.statusText();
+    mojoResponse->blob_uuid = response.blobUUID();
+    mojoResponse->blob_size = response.blobSize();
+    mojoResponse->stream_url = response.streamURL().string();
+    callback.Run(true, std::move(mojoResponse));
+    return;
+  }
+
+  m_client.respondToFetchEvent(responseID, response);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::didHandleFetchEvent(int eventFinishID, WebServiceWorkerEventResult result)
 {
-    m_client.didHandleFetchEvent(eventFinishID, result);
+    m_hostProcess->DidHandleSimpleEvent(eventFinishID, result);
+    // m_client.didHandleFetchEvent(eventFinishID, result);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::didHandleInstallEvent(int installEventID, WebServiceWorkerEventResult result)
 {
     m_client.didHandleInstallEvent(installEventID, result);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::didHandleNotificationClickEvent(int eventID, WebServiceWorkerEventResult result)
 {
     m_client.didHandleNotificationClickEvent(eventID, result);
@@ skipping 42 matching lines @@
 void ServiceWorkerGlobalScopeClientImpl::navigate(const WebString& clientUUID, const WebURL& url, WebServiceWorkerClientCallbacks* callback)
 {
     m_client.navigate(clientUUID, url, callback);
 }
 
 void ServiceWorkerGlobalScopeClientImpl::registerForeignFetchScopes(const WebVector<WebURL>& subScopes, const WebVector<WebSecurityOrigin>& origins)
 {
     m_client.registerForeignFetchScopes(subScopes, origins);
 }
 
+void ServiceWorkerGlobalScopeClientImpl::DispatchPingEvent(const WTF::String& message)
+{
+    LOG(ERROR) << __PRETTY_FUNCTION__;
+    return;
+}
+
+void ServiceWorkerGlobalScopeClientImpl::DispatchFetchEvent(int responseID, int eventFinishID, mojom::blink::ServiceWorkerFetchRequestPtr mojoRequest, const DispatchFetchEventCallback& callback) {
+    LOG(ERROR) << "(request: " << mojoRequest->url.getString().ascii().data() << ")";
+
+    m_fetchCallbacks.set(responseID, callback);
+
+    WebServiceWorkerRequest webRequest;
+    ScriptState::Scope scope(workerGlobalScope()->scriptController()->getScriptState());
+    WaitUntilObserver* waitUntilObserver = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Fetch, eventFinishID);
+    RespondWithObserver* respondWithObserver = RespondWithObserver::create(workerGlobalScope(), responseID, webRequest.url(), webRequest.mode(), webRequest.frameType(), webRequest.requestContext(), waitUntilObserver);
+    Request* request = Request::create(workerGlobalScope()->scriptController()->getScriptState(), webRequest);
+    request->getHeaders()->setGuard(Headers::ImmutableGuard);
+    FetchEventInit eventInit;
+    eventInit.setCancelable(true);
+    eventInit.setRequest(request);
+    eventInit.setClientId(webRequest.isMainResourceLoad() ? WebString() : webRequest.clientId());
+    eventInit.setIsReload(webRequest.isReload());
+    FetchEvent* fetchEvent = FetchEvent::create(workerGlobalScope()->scriptController()->getScriptState(), EventTypeNames::fetch, eventInit, respondWithObserver, waitUntilObserver);
+    waitUntilObserver->willDispatchEvent();
+    DispatchEventResult dispatchResult = workerGlobalScope()->dispatchEvent(fetchEvent);
+    respondWithObserver->didDispatchEvent(dispatchResult);
+    // false is okay because waitUntil for fetch event doesn't care about the
+    // promise rejection or an uncaught runtime script error.
+    waitUntilObserver->didDispatchEvent(false /* errorOccurred */);
+}
+
+
 ServiceWorkerGlobalScopeClientImpl::ServiceWorkerGlobalScopeClientImpl(WebServiceWorkerContextClient& client)
     : m_client(client)
 {
 }
 
+mojom::blink::ServiceWorkerGlobalScopeHostPtr& ServiceWorkerGlobalScopeClientImpl::hostProcess()
+{
+    if (!m_hostProcess) {
+        m_client.serviceRegistry()->connectToRemoteService(mojo::GetProxy(&m_hostProcess));
+        m_hostProcess->SetClient(m_clientBinding->CreateInterfacePtrAndBind());
+    }
+    return m_hostProcess;
+}
+
+ServiceWorkerGlobalScope* ServiceWorkerGlobalScopeClientImpl::workerGlobalScope()
+{
+    return m_parent.get();
+}
+
 } // namespace blink