Start implementing ForeignFetchEvent for foreign fetch events.

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp

 /*
  * Copyright (C) 2013 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 33 matching lines @@
 #include "modules/geofencing/CircularGeofencingRegion.h"
 #include "modules/geofencing/GeofencingEvent.h"
 #include "modules/notifications/Notification.h"
 #include "modules/notifications/NotificationEvent.h"
 #include "modules/notifications/NotificationEventInit.h"
 #include "modules/push_messaging/PushEvent.h"
 #include "modules/push_messaging/PushMessageData.h"
 #include "modules/serviceworkers/ExtendableEvent.h"
 #include "modules/serviceworkers/ExtendableMessageEvent.h"
 #include "modules/serviceworkers/FetchEvent.h"
+#include "modules/serviceworkers/ForeignFetchEvent.h"
 #include "modules/serviceworkers/InstallEvent.h"
 #include "modules/serviceworkers/ServiceWorkerClient.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
 #include "modules/serviceworkers/ServiceWorkerWindowClient.h"
 #include "modules/serviceworkers/WaitUntilObserver.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "public/platform/modules/notifications/WebNotificationData.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerEventResult.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerRequest.h"
 #include "public/web/WebSerializedScriptValue.h"
@@ skipping 65 matching lines @@
         origin = sourceOrigin.toString();
     ServiceWorker* source = ServiceWorker::from(m_workerGlobalScope->getExecutionContext(), handle.release());
     WaitUntilObserver* observer = WaitUntilObserver::create(workerGlobalScope(), WaitUntilObserver::Message, eventID);
 
     RawPtr<Event> event(ExtendableMessageEvent::create(value, origin, ports, source, observer));
     workerGlobalScope()->dispatchExtendableEvent(event.release(), observer);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchFetchEvent(int eventID, const WebServiceWorkerRequest& webRequest)
 {
-    dispatchFetchEventImpl(eventID, webRequest, EventTypeNames::fetch);
+    RespondWithObserver* observer = RespondWithObserver::create(workerGlobalScope(), eventID, webRequest.url(), webRequest.mode(), webRequest.frameType(), webRequest.requestContext());
+    Request* request = Request::create(workerGlobalScope(), 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(EventTypeNames::fetch, eventInit, observer);
+    DispatchEventResult dispatchResult = workerGlobalScope()->dispatchEvent(fetchEvent);
+    observer->didDispatchEvent(dispatchResult);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchForeignFetchEvent(int eventID, const WebServiceWorkerRequest& webRequest)
 {
-    dispatchFetchEventImpl(eventID, webRequest, EventTypeNames::foreignfetch);
+    ForeignFetchRespondWithObserver* observer = ForeignFetchRespondWithObserver::create(workerGlobalScope(), eventID, webRequest.url(), webRequest.mode(), webRequest.frameType(), webRequest.requestContext());
+    Request* request = Request::create(workerGlobalScope(), webRequest);
+    request->getHeaders()->setGuard(Headers::ImmutableGuard);
+    ForeignFetchEventInit eventInit;
+    eventInit.setCancelable(true);
+    eventInit.setRequest(request);
+    ForeignFetchEvent* fetchEvent = ForeignFetchEvent::create(EventTypeNames::foreignfetch, eventInit, observer);
+    DispatchEventResult dispatchResult = workerGlobalScope()->dispatchEvent(fetchEvent);
+    observer->didDispatchEvent(dispatchResult);
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchGeofencingEvent(int eventID, WebGeofencingEventType eventType, const WebString& regionID, const WebCircularGeofencingRegion& region)
 {
     const AtomicString& type = eventType == WebGeofencingEventTypeEnter ? EventTypeNames::geofenceenter : EventTypeNames::geofenceleave;
     workerGlobalScope()->dispatchEvent(GeofencingEvent::create(type, regionID, CircularGeofencingRegion::create(regionID, region)));
 }
 
 void ServiceWorkerGlobalScopeProxy::dispatchInstallEvent(int eventID)
 {
@@ skipping 131 matching lines @@
     DCHECK(m_document);
     return *m_document;
 }
 
 ServiceWorkerGlobalScope* ServiceWorkerGlobalScopeProxy::workerGlobalScope() const
 {
     DCHECK(m_workerGlobalScope);
     return m_workerGlobalScope;
 }
 
-void ServiceWorkerGlobalScopeProxy::dispatchFetchEventImpl(int eventID, const WebServiceWorkerRequest& webRequest, const AtomicString& eventTypeName)

[Nate Chapin, 2016/04/07 20:51:04]

I would be inclined to keep the common logic in a helper, but I guess it's
debatable whether there's enough common logic remaining to justify the helper?

[Marijn Kruisselbrink, 2016/04/07 21:00:06]

Yeah, pretty much the last three lines are the only common logic, and even then
with different types, so needing templates like this:

template <typename EventType, typename EventInitType>
void ServiceWorkerGlobalScopeProxy::dispatchFetchEventImpl(RespondWithObserver*
observer, const EventInitType& eventInit, const AtomicString& eventTypeName) {
  EventType* event = EventType::create(eventTypeName, eventInit, observer);
  DispatchEventResult dispatchResult =
workerGlobalScope()->dispatchEvent(event);
  observer->didDipatchEvent(dispatchResult);
}

Which doesn't really seem worth it (alternatively without templates just the
last two lines could be common logic).

-{
-    RespondWithObserver* observer = RespondWithObserver::create(workerGlobalScope(), eventID, webRequest.url(), webRequest.mode(), webRequest.frameType(), webRequest.requestContext());
-    Request* request = Request::create(workerGlobalScope(), 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());
-    RawPtr<FetchEvent> fetchEvent(FetchEvent::create(eventTypeName, eventInit, observer));
-    DispatchEventResult dispatchResult = workerGlobalScope()->dispatchEvent(fetchEvent.release());
-    observer->didDispatchEvent(dispatchResult);
-}
-
 } // namespace blink