[WIP] Mojofy respondwith

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

 // Copyright 2014 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/FetchRespondWithObserver.h"
 
 #include <v8.h>
 #include "bindings/core/v8/ScriptValue.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/modules/v8/V8Response.h"
@@ skipping 133 matching lines @@
   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_eventID, webResponse, m_eventDispatchTime);
+      ->respondToFetchEventWithResponse(m_eventID, webResponse,
+                                        m_eventDispatchTime);
 }
 
 void FetchRespondWithObserver::onResponseFulfilled(const ScriptValue& value) {
   DCHECK(getExecutionContext());
   if (!V8Response::hasInstance(value.v8Value(),
                                toIsolate(getExecutionContext()))) {
     onResponseRejected(WebServiceWorkerResponseErrorNoV8Instance);
     return;
   }
   Response* response = V8Response::toImplWithTypeCheck(
@@ skipping 41 matching lines @@
     return;
   }
   if (response->bodyUsed()) {
     onResponseRejected(WebServiceWorkerResponseErrorBodyUsed);
     return;
   }
 
   WebServiceWorkerResponse webResponse;
   response->populateWebServiceWorkerResponse(webResponse);
   BodyStreamBuffer* buffer = response->internalBodyBuffer();
-  if (buffer) {
+  if (!buffer) {
+    ServiceWorkerGlobalScopeClient::from(getExecutionContext())
+        ->respondToFetchEventWithResponse(m_eventID, webResponse,
+                                          m_eventDispatchTime);
+  } else {
     RefPtr<BlobDataHandle> blobDataHandle = buffer->drainAsBlobDataHandle(
         BytesConsumer::BlobSizePolicy::AllowBlobWithInvalidSize);
     if (blobDataHandle) {
       webResponse.setBlobDataHandle(blobDataHandle);
+      ServiceWorkerGlobalScopeClient::from(getExecutionContext())
+          ->respondToFetchEventWithResponse(m_eventID, webResponse,
+                                            m_eventDispatchTime);
     } else {
-      Stream* outStream = Stream::create(getExecutionContext(), "");
-      webResponse.setStreamURL(outStream->url());
-      buffer->startLoading(FetchDataLoader::createLoaderAsStream(outStream),
+      MojoCreateDataPipeOptions options;
+      options.struct_size = sizeof(MojoCreateDataPipeOptions);
+      options.flags = MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE;
+      options.element_num_bytes = 1;
+      options.capacity_num_bytes = 512 * 1024;
+      mojo::DataPipe data_pipe(options);
+      DCHECK(data_pipe.producer_handle.is_valid());
+      DCHECK(data_pipe.consumer_handle.is_valid());
+      buffer->startLoading(FetchDataLoader::createLoaderAsDataPipe(
+                               std::move(data_pipe.producer_handle)),
                            new NoopLoaderClient);
+      ServiceWorkerGlobalScopeClient::from(getExecutionContext())
+          ->respondToFetchEventWithResponseStream(
+              m_eventID, webResponse, std::move(data_pipe.consumer_handle),
+              m_eventDispatchTime);
     }
   }
-  ServiceWorkerGlobalScopeClient::from(getExecutionContext())
-      ->respondToFetchEvent(m_eventID, webResponse, m_eventDispatchTime);
 }
 
 void FetchRespondWithObserver::onNoResponse() {
   ServiceWorkerGlobalScopeClient::from(getExecutionContext())
       ->respondToFetchEvent(m_eventID, m_eventDispatchTime);
 }
 
 FetchRespondWithObserver::FetchRespondWithObserver(
     ExecutionContext* context,
     int fetchEventID,
     const KURL& requestURL,
     WebURLRequest::FetchRequestMode requestMode,
     WebURLRequest::FetchRedirectMode redirectMode,
     WebURLRequest::FrameType frameType,
     WebURLRequest::RequestContext requestContext,
     WaitUntilObserver* observer)
     : RespondWithObserver(context, fetchEventID, observer),
       m_requestURL(requestURL),
       m_requestMode(requestMode),
       m_redirectMode(redirectMode),
       m_frameType(frameType),
       m_requestContext(requestContext) {}
 
 DEFINE_TRACE(FetchRespondWithObserver) {
   RespondWithObserver::trace(visitor);
 }
 
 }  // namespace blink