Implement FetchEvent.navigationPreload

third_party/WebKit/Source/modules/serviceworkers/FetchEvent.cpp

Index: third_party/WebKit/Source/modules/serviceworkers/FetchEvent.cpp
diff --git a/third_party/WebKit/Source/modules/serviceworkers/FetchEvent.cpp b/third_party/WebKit/Source/modules/serviceworkers/FetchEvent.cpp
index 8fbfe0a4f40226baeab272924e7e50b0ce705893..e68532247a43b112466977e4046863bf51296598 100644
--- a/third_party/WebKit/Source/modules/serviceworkers/FetchEvent.cpp
+++ b/third_party/WebKit/Source/modules/serviceworkers/FetchEvent.cpp
@@ -6,8 +6,12 @@
 
 #include "bindings/core/v8/ToV8.h"
 #include "bindings/core/v8/V8HiddenValue.h"
+#include "modules/fetch/BytesConsumerForDataConsumerHandle.h"
 #include "modules/fetch/Request.h"
+#include "modules/fetch/Response.h"
+#include "modules/serviceworkers/ServiceWorkerError.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScope.h"
+#include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "wtf/RefPtr.h"
 
 namespace blink {
@@ -15,16 +19,18 @@ namespace blink {
 FetchEvent* FetchEvent::create(ScriptState* scriptState,
                                const AtomicString& type,
                                const FetchEventInit& initializer) {
-  return new FetchEvent(scriptState, type, initializer, nullptr, nullptr);
+  return new FetchEvent(scriptState, type, initializer, nullptr, nullptr,
+                        false);
 }
 
 FetchEvent* FetchEvent::create(ScriptState* scriptState,
                                const AtomicString& type,
                                const FetchEventInit& initializer,
                                RespondWithObserver* respondWithObserver,
-                               WaitUntilObserver* waitUntilObserver) {
+                               WaitUntilObserver* waitUntilObserver,
+                               bool navigationPreloadSent) {
   return new FetchEvent(scriptState, type, initializer, respondWithObserver,
-                        waitUntilObserver);
+                        waitUntilObserver, navigationPreloadSent);
 }
 
 Request* FetchEvent::request() const {
@@ -47,6 +53,15 @@ void FetchEvent::respondWith(ScriptState* scriptState,
     m_observer->respondWith(scriptState, scriptPromise, exceptionState);
 }
 
+ScriptPromise FetchEvent::navigationPreload(ScriptState* scriptState,
+                                            bool& isNull) {
+  if (!m_navigationPreloadProperty) {
+    isNull = true;
+    return ScriptPromise();
+  }
+  return m_navigationPreloadProperty->promise(scriptState->world());
+}
+
 const AtomicString& FetchEvent::interfaceName() const {
   return EventNames::FetchEvent;
 }
@@ -55,9 +70,16 @@ FetchEvent::FetchEvent(ScriptState* scriptState,
                        const AtomicString& type,
                        const FetchEventInit& initializer,
                        RespondWithObserver* respondWithObserver,
-                       WaitUntilObserver* waitUntilObserver)
+                       WaitUntilObserver* waitUntilObserver,
+                       bool navigationPreloadSent)
     : ExtendableEvent(type, initializer, waitUntilObserver),
       m_observer(respondWithObserver) {
+  if (navigationPreloadSent) {
+    m_navigationPreloadProperty =
+        new PreloadResponseProperty(scriptState->getExecutionContext(), this,
+                                    PreloadResponseProperty::PreloadResponse);
+  }
+
   m_clientId = initializer.clientId();
   m_isReload = initializer.isReload();
   if (initializer.hasRequest()) {
@@ -84,9 +106,73 @@ FetchEvent::FetchEvent(ScriptState* scriptState,
   }
 }
 
+class FetchEvent::PreloadResponseCallbackImpl
+    : public WebServiceWorkerPreloadResponseCallbacks {
+ public:
+  explicit PreloadResponseCallbackImpl(

[falken, 2016/10/19 06:00:13]

nit: dont need explicit

[horo, 2016/10/19 07:11:45]

Done.

+      FetchEvent::PreloadResponseProperty* preloadResponseProperty,
+      ScriptState* scriptState)
+      : m_navigationPreloadProperty(preloadResponseProperty),
+        m_scriptState(scriptState) {}
+  ~PreloadResponseCallbackImpl() override {}
+
+  void onSuccess(
+      WebServiceWorkerPreloadResponseCallbacksResult* result) override {
+    if (!m_navigationPreloadProperty->getExecutionContext() ||
+        m_navigationPreloadProperty->getExecutionContext()
+            ->activeDOMObjectsAreStopped()) {
+      return;
+    }
+    ScriptState::Scope scope(m_scriptState.get());
+    FetchResponseData* responseData =
+        FetchResponseData::createWithBuffer(new BodyStreamBuffer(
+            m_scriptState.get(),
+            new BytesConsumerForDataConsumerHandle(
+                m_navigationPreloadProperty->getExecutionContext(),
+                std::move(result->handle))));
+    responseData->setURL(result->response->url());
+    responseData->setStatus(result->response->status());
+    responseData->setStatusMessage(result->response->statusText());
+    responseData->setResponseTime(result->response->responseTime());
+    for (HTTPHeaderMap::const_iterator i = result->response->headers().begin(),
+                                       end = result->response->headers().end();
+         i != end; ++i) {
+      responseData->headerList()->append(i->key, i->value);
+    }
+
+    FetchResponseData* taintedResponse =
+        responseData->createBasicFilteredResponse();
+    m_navigationPreloadProperty->resolve(Response::create(
+        m_navigationPreloadProperty->getExecutionContext(), taintedResponse));
+  }
+
+  void onError(WebServiceWorkerError error) override {
+    if (!m_navigationPreloadProperty->getExecutionContext() ||
+        m_navigationPreloadProperty->getExecutionContext()
+            ->activeDOMObjectsAreStopped()) {
+      return;
+    }
+    m_navigationPreloadProperty->reject(
+        ServiceWorkerError::take(nullptr, error));
+  }
+
+ private:
+  Persistent<FetchEvent::PreloadResponseProperty> m_navigationPreloadProperty;
+  RefPtr<ScriptState> m_scriptState;
+
+  WTF_MAKE_NONCOPYABLE(PreloadResponseCallbackImpl);
+};
+
+WebServiceWorkerPreloadResponseCallbacks*
+FetchEvent::createPreloadResponseCallback(ScriptState* scriptState) {
+  return new PreloadResponseCallbackImpl(m_navigationPreloadProperty,
+                                         scriptState);
+}
+
 DEFINE_TRACE(FetchEvent) {
   visitor->trace(m_observer);
   visitor->trace(m_request);
+  visitor->trace(m_navigationPreloadProperty);
   ExtendableEvent::trace(visitor);
 }