Start implementing ForeignFetchEvent for foreign fetch events.

third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp

Index: third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp
diff --git a/third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp b/third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp
index bbdcbbe7f0bd4297a20110ad017f8a547ff93c79..db16095464062d9c9b29152b955190fc3944b0b7 100644
--- a/third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp
+++ b/third_party/WebKit/Source/web/ServiceWorkerGlobalScopeProxy.cpp
@@ -51,6 +51,7 @@
 #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"
@@ -136,12 +137,30 @@ void ServiceWorkerGlobalScopeProxy::dispatchExtendableMessageEvent(int eventID,
 
 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)
@@ -293,19 +312,4 @@ ServiceWorkerGlobalScope* ServiceWorkerGlobalScopeProxy::workerGlobalScope() con
     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