[WIP] RespondWithObserver

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

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// Copyright 2017 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.
 
-#include "modules/serviceworkers/RespondWithObserver.h"
+#include "modules/serviceworkers/FetchRespondWithObserver.h"
 
-#include "bindings/core/v8/ScriptFunction.h"
-#include "bindings/core/v8/ScriptPromise.h"
+#include <v8.h>
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8Response.h"
-#include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/inspector/ConsoleMessage.h"
+#include "core/inspector/ConsoleTypes.h"
 #include "core/streams/Stream.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/BytesConsumer.h"
 #include "modules/serviceworkers/ServiceWorkerGlobalScopeClient.h"
-#include "platform/RuntimeEnabledFeatures.h"
+#include "modules/serviceworkers/WaitUntilObserver.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
-#include "wtf/Assertions.h"
-#include "wtf/RefPtr.h"
-#include <v8.h>
 
 namespace blink {
 namespace {
 
 // Returns the error message to let the developer know about the reason of the
 // unusual failures.
 const String getMessageForResponseError(WebServiceWorkerResponseError error,
                                         const KURL& requestURL) {
   String errorMessage = "The FetchEvent for \"" + requestURL.getString() +
                         "\" resulted in a network error response: ";
@@ skipping 14 matching lines @@
     case WebServiceWorkerResponseErrorResponseTypeError:
       errorMessage = errorMessage +
                      "the promise was resolved with an error response object.";
       break;
     case WebServiceWorkerResponseErrorResponseTypeOpaque:
       errorMessage = errorMessage +
                      "an \"opaque\" response was used for a request whose type "
                      "is not no-cors";
       break;
     case WebServiceWorkerResponseErrorResponseTypeNotBasicOrDefault:
-      ASSERT_NOT_REACHED();
+      NOTREACHED();
       break;
     case WebServiceWorkerResponseErrorBodyUsed:
       errorMessage = errorMessage +
                      "a Response whose \"bodyUsed\" is \"true\" cannot be used "
                      "to respond to a request.";
       break;
     case WebServiceWorkerResponseErrorResponseTypeOpaqueForClientRequest:
       errorMessage = errorMessage +
                      "an \"opaque\" response was used for a client request.";
       break;
@@ skipping 69 matching lines @@
 
  public:
   NoopLoaderClient() = default;
   void didFetchDataLoadedStream() override {}
   void didFetchDataLoadFailed() override {}
   DEFINE_INLINE_TRACE() { FetchDataLoader::Client::trace(visitor); }
 };
 
 }  // namespace
 
-class RespondWithObserver::ThenFunction final : public ScriptFunction {
- public:
-  enum ResolveType {
-    Fulfilled,
-    Rejected,
-  };
+FetchRespondWithObserver::~FetchRespondWithObserver() {}
 
-  static v8::Local<v8::Function> createFunction(ScriptState* scriptState,
-                                                RespondWithObserver* observer,
-                                                ResolveType type) {
-    ThenFunction* self = new ThenFunction(scriptState, observer, type);
-    return self->bindToV8Function();
-  }
-
-  DEFINE_INLINE_VIRTUAL_TRACE() {
-    visitor->trace(m_observer);
-    ScriptFunction::trace(visitor);
-  }
-
- private:
-  ThenFunction(ScriptState* scriptState,
-               RespondWithObserver* observer,
-               ResolveType type)
-      : ScriptFunction(scriptState),
-        m_observer(observer),
-        m_resolveType(type) {}
-
-  ScriptValue call(ScriptValue value) override {
-    ASSERT(m_observer);
-    ASSERT(m_resolveType == Fulfilled || m_resolveType == Rejected);
-    if (m_resolveType == Rejected) {
-      m_observer->responseWasRejected(
-          WebServiceWorkerResponseErrorPromiseRejected);
-      value =
-          ScriptPromise::reject(value.getScriptState(), value).getScriptValue();
-    } else {
-      m_observer->responseWasFulfilled(value);
-    }
-    m_observer = nullptr;
-    return value;
-  }
-
-  Member<RespondWithObserver> m_observer;
-  ResolveType m_resolveType;
-};
-
-RespondWithObserver::~RespondWithObserver() {}
-
-RespondWithObserver* RespondWithObserver::create(
+FetchRespondWithObserver* FetchRespondWithObserver::create(
     ExecutionContext* context,
     int fetchEventID,
     const KURL& requestURL,
     WebURLRequest::FetchRequestMode requestMode,
     WebURLRequest::FetchRedirectMode redirectMode,
     WebURLRequest::FrameType frameType,
     WebURLRequest::RequestContext requestContext,
     WaitUntilObserver* observer) {
-  return new RespondWithObserver(context, fetchEventID, requestURL, requestMode,
-                                 redirectMode, frameType, requestContext,
-                                 observer);
+  return new FetchRespondWithObserver(context, fetchEventID, requestURL,
+                                      requestMode, redirectMode, frameType,
+                                      requestContext, observer);
 }
 
-void RespondWithObserver::contextDestroyed(ExecutionContext*) {
-  if (m_observer) {
-    DCHECK_EQ(Pending, m_state);
-    m_observer.clear();
-  }
-  m_state = Done;
-}
-
-void RespondWithObserver::willDispatchEvent() {
-  m_eventDispatchTime = WTF::currentTime();
-}
-
-void RespondWithObserver::didDispatchEvent(DispatchEventResult dispatchResult) {
-  ASSERT(getExecutionContext());
+void FetchRespondWithObserver::didDispatchEvent(
+    DispatchEventResult dispatchResult) {
+  DCHECK(getExecutionContext());
   if (m_state != Initial)
     return;
 
   if (dispatchResult != DispatchEventResult::NotCanceled) {
     m_observer->incrementPendingActivity();
     responseWasRejected(WebServiceWorkerResponseErrorDefaultPrevented);
     return;
   }
 
   ServiceWorkerGlobalScopeClient::from(getExecutionContext())
-      ->respondToFetchEvent(m_fetchEventID, m_eventDispatchTime);
+      ->respondToFetchEvent(m_eventID, m_eventDispatchTime);
   m_state = Done;
   m_observer.clear();
 }
 
-void RespondWithObserver::respondWith(ScriptState* scriptState,
-                                      ScriptPromise scriptPromise,
-                                      ExceptionState& exceptionState) {
-  if (m_state != Initial) {
-    exceptionState.throwDOMException(
-        InvalidStateError, "The fetch event has already been responded to.");
-    return;
-  }
-
-  m_state = Pending;
-  m_observer->incrementPendingActivity();
-  scriptPromise.then(
-      ThenFunction::createFunction(scriptState, this, ThenFunction::Fulfilled),
-      ThenFunction::createFunction(scriptState, this, ThenFunction::Rejected));
-}
-
-void RespondWithObserver::responseWasRejected(
+void FetchRespondWithObserver::responseWasRejected(
     WebServiceWorkerResponseError error) {
-  ASSERT(getExecutionContext());
+  DCHECK(getExecutionContext());
   getExecutionContext()->addConsoleMessage(
       ConsoleMessage::create(JSMessageSource, WarningMessageLevel,
                              getMessageForResponseError(error, m_requestURL)));
 
   // The default value of WebServiceWorkerResponse's status is 0, which maps
   // to a network error.
   WebServiceWorkerResponse webResponse;
   webResponse.setError(error);
   ServiceWorkerGlobalScopeClient::from(getExecutionContext())
-      ->respondToFetchEvent(m_fetchEventID, webResponse, m_eventDispatchTime);
-  m_state = Done;
-  m_observer->decrementPendingActivity();
-  m_observer.clear();
+      ->respondToFetchEvent(m_eventID, webResponse, m_eventDispatchTime);
+  RespondWithObserver::responseWasRejected(error);
 }
 
-void RespondWithObserver::responseWasFulfilled(const ScriptValue& value) {
-  ASSERT(getExecutionContext());
+void FetchRespondWithObserver::responseWasFulfilled(const ScriptValue& value) {
+  DCHECK(getExecutionContext());
   if (!V8Response::hasInstance(value.v8Value(),
                                toIsolate(getExecutionContext()))) {
     responseWasRejected(WebServiceWorkerResponseErrorNoV8Instance);
     return;
   }
   Response* response = V8Response::toImplWithTypeCheck(
       toIsolate(getExecutionContext()), value.v8Value());
   // "If one of the following conditions is true, return a network error:
   //   - |response|'s type is |error|.
   //   - |request|'s mode is not |no-cors| and response's type is |opaque|.
@@ skipping 60 matching lines @@
     if (blobDataHandle) {
       webResponse.setBlobDataHandle(blobDataHandle);
     } else {
       Stream* outStream = Stream::create(getExecutionContext(), "");
       webResponse.setStreamURL(outStream->url());
       buffer->startLoading(FetchDataLoader::createLoaderAsStream(outStream),
                            new NoopLoaderClient);
     }
   }
   ServiceWorkerGlobalScopeClient::from(getExecutionContext())
-      ->respondToFetchEvent(m_fetchEventID, webResponse, m_eventDispatchTime);
-  m_state = Done;
-  m_observer->decrementPendingActivity();
-  m_observer.clear();
+      ->respondToFetchEvent(m_eventID, webResponse, m_eventDispatchTime);
+  RespondWithObserver::responseWasFulfilled(value);
 }
 
-RespondWithObserver::RespondWithObserver(
+FetchRespondWithObserver::FetchRespondWithObserver(
     ExecutionContext* context,
     int fetchEventID,
     const KURL& requestURL,
     WebURLRequest::FetchRequestMode requestMode,
     WebURLRequest::FetchRedirectMode redirectMode,
     WebURLRequest::FrameType frameType,
     WebURLRequest::RequestContext requestContext,
     WaitUntilObserver* observer)
-    : ContextLifecycleObserver(context),
-      m_fetchEventID(fetchEventID),
+    : RespondWithObserver(context, fetchEventID, observer),
       m_requestURL(requestURL),
       m_requestMode(requestMode),
       m_redirectMode(redirectMode),
       m_frameType(frameType),
-      m_requestContext(requestContext),
-      m_state(Initial),
-      m_observer(observer) {}
+      m_requestContext(requestContext) {}
 
-DEFINE_TRACE(RespondWithObserver) {
-  visitor->trace(m_observer);
-  ContextLifecycleObserver::trace(visitor);
+DEFINE_TRACE(FetchRespondWithObserver) {
+  RespondWithObserver::trace(visitor);
 }
 
 }  // namespace blink