[wasm] response-based compile APIs

third_party/WebKit/Source/modules/fetch/FetchDataLoader.cpp

 // Copyright 2015 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/fetch/FetchDataLoader.h"
 
 #include "core/html/parser/TextResourceDecoder.h"
 #include "modules/fetch/BytesConsumer.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/WTFString.h"
 #include "wtf/typed_arrays/ArrayBufferBuilder.h"
 #include <memory>
 
 namespace blink {
 
 namespace {
 
 class FetchDataLoaderAsBlobHandle final : public FetchDataLoader,
                                           public BytesConsumer::Client {
   USING_GARBAGE_COLLECTED_MIXIN(FetchDataLoaderAsBlobHandle);
 
  public:
-  explicit FetchDataLoaderAsBlobHandle(const String& mimeType)
-      : m_mimeType(mimeType) {}
+  FetchDataLoaderAsBlobHandle(const String& mimeType) : m_mimeType(mimeType) {}
 
   void start(BytesConsumer* consumer,
              FetchDataLoader::Client* client) override {
     DCHECK(!m_client);
     DCHECK(!m_consumer);
 
     m_client = client;
     m_consumer = consumer;
 
     RefPtr<BlobDataHandle> blobHandle = m_consumer->drainAsBlobDataHandle();
@@ skipping 262 matching lines @@
     visitor->trace(m_outStream);
     FetchDataLoader::trace(visitor);
     BytesConsumer::Client::trace(visitor);
   }
 
   Member<BytesConsumer> m_consumer;
   Member<FetchDataLoader::Client> m_client;
   Member<Stream> m_outStream;
 };
 
+class FetchDataLoaderAsWasmModule final : public FetchDataLoader,
+                                          public BytesConsumer::Client {
+  USING_GARBAGE_COLLECTED_MIXIN(FetchDataLoaderAsWasmModule);
+
+ public:
+  explicit FetchDataLoaderAsWasmModule(v8::Isolate* isolate,
+                                       ScriptPromiseResolver* resolver,
+                                       ScriptState* scriptState)

[haraken, 2017/04/04 06:05:31]

Drop explicit.

+      : m_resolver(resolver), m_builder(isolate), m_scriptState(scriptState) {}
+
+  void start(BytesConsumer* consumer,
+             FetchDataLoader::Client* client) override {
+    DCHECK(!m_consumer);
+    DCHECK(!m_client);
+    m_client = client;
+    m_consumer = consumer;
+    m_consumer->setClient(this);
+    onStateChange();
+  }
+
+  void onStateChange() override {
+    while (true) {
+      const char* buffer;
+      size_t available;
+      BytesConsumer::Result result = m_consumer->beginRead(&buffer, &available);
+
+      switch (result) {
+        case BytesConsumer::Result::ShouldWait:
+          return;
+        case BytesConsumer::Result::Ok: {
+          sendBytes(buffer, available);
+          result = m_consumer->endRead(available);
+          if (result == BytesConsumer::Result::Error) {
+            m_resolver->reject();
+          }
+          break;
+        }
+        case BytesConsumer::Result::Done: {
+          DCHECK_EQ(available, 0U);
+          v8::Isolate* isolate = m_resolver->getScriptState()->isolate();
+          ScriptState::Scope scope(m_scriptState.get());
+          v8::TryCatch trycatch(isolate);
+          v8::Local<v8::WasmCompiledModule> module;
+          if (m_builder.Finish().ToLocal(&module)) {
+            DCHECK(!trycatch.HasCaught());
+            ScriptValue scriptValue(m_scriptState.get(), module);
+            m_resolver->resolve(scriptValue);
+          } else {
+            DCHECK(trycatch.HasCaught());
+            m_resolver->reject(trycatch.Exception());
+            trycatch.Reset();
+          }
+          m_client->didFetchDataLoadedStream();
+          return;
+        }
+        case BytesConsumer::Result::Error: {
+          // TODO(mtrofin): do we need an abort on the wasm side?
+          // m_outStream->abort();
+          m_client->didFetchDataLoadFailed();
+          return;
+        }
+      }
+    }
+  }
+
+  void cancel() override { m_consumer->cancel(); }
+
+  DEFINE_INLINE_TRACE() {
+    visitor->trace(m_consumer);
+    visitor->trace(m_resolver);
+    visitor->trace(m_client);
+    FetchDataLoader::trace(visitor);
+    BytesConsumer::Client::trace(visitor);
+  }
+
+ private:
+  void sendBytes(const char* bytes, size_t size) {
+    std::unique_ptr<uint8_t[]> bufferCopy(new uint8_t[size]);

[haraken, 2017/04/04 06:05:31]

We should use fastMalloc / fastFree instead of new.

In the first place, however, is there any way to avoid creating the copy? i.e.,
pass the bytes directly to v8::WasmModuleObjectBuilde and make it work.

[Mircea Trofin, 2017/04/04 06:48:07]

Oh, good point - thats anyway what we want to do once the wasm side is fully
implemented (right now it's just a dumb skeleton). I'll prep the v8 side.

+    memcpy(bufferCopy.get(), bytes, size);
+    // TODO(mtrofin): we want to extend OnBytesReceived to test
+    // for decoding errors or for compilation errors that
+    // happened meanwhile.
+    m_builder.OnBytesReceived(
+        std::unique_ptr<const uint8_t[]>(
+            const_cast<const uint8_t*>(bufferCopy.release())),
+        size);
+  }
+
+  Member<BytesConsumer> m_consumer;
+  Member<ScriptPromiseResolver> m_resolver;
+  Member<FetchDataLoader::Client> m_client;
+  v8::WasmModuleObjectBuilder m_builder;
+  const RefPtr<ScriptState> m_scriptState;
+};
+
 }  // namespace
 
 FetchDataLoader* FetchDataLoader::createLoaderAsBlobHandle(
     const String& mimeType) {
   return new FetchDataLoaderAsBlobHandle(mimeType);
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsArrayBuffer() {
   return new FetchDataLoaderAsArrayBuffer();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsString() {
   return new FetchDataLoaderAsString();
 }
 
 FetchDataLoader* FetchDataLoader::createLoaderAsStream(Stream* outStream) {
   return new FetchDataLoaderAsStream(outStream);
 }
 
+FetchDataLoader* FetchDataLoader::createLoaderAsWasmModule(
+    v8::Isolate* isolate,
+    ScriptPromiseResolver* resolver,
+    ScriptState* scriptState) {
+  return new FetchDataLoaderAsWasmModule(isolate, resolver, scriptState);
+}
+
 }  // namespace blink