[wasm] Skeleton WasmModuleObjectBuilder for streamed compilation

include/v8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 3896 matching lines @@
                                Local<Object> local_target,
                                Local<Object> local_handler);
 
   V8_INLINE static Proxy* Cast(Value* obj);
 
  private:
   Proxy();
   static void CheckCast(Value* obj);
 };
 
+// TODO(mtrofin): rename WasmCompiledModule to WasmModuleObject, for

[clemensh, 2017/03/27 07:39:20]

FYI: Ben once had the plan to rename this to WasmSpecializedCode.
The problem with the current name (and also "WasmModuleObject") is that this
suggests that only one such object exists per module, which is not the case.

[Mircea Trofin, 2017/03/27 07:58:30]

By "module" you mean "wire bytes"?

An instance of WasmCompiledModule is the v8 wrapping of an instance of the JS
type "WebAssembly.Module".  Not sure where the problem is: the user knows they
can create multiple WebAssembly.Module objects from the same instance of wire
bytes. Same here.

+// consistency with internal APIs.
 class V8_EXPORT WasmCompiledModule : public Object {
  public:
   typedef std::pair<std::unique_ptr<const uint8_t[]>, size_t> SerializedModule;
   // A buffer that is owned by the caller.
   typedef std::pair<const uint8_t*, size_t> CallerOwnedBuffer;
 
   // An opaque, native heap object for transferring wasm modules. It
   // supports move semantics, and does not support copy semantics.
   class TransferrableModule final {
    public:
@@ skipping 31 matching lines @@
   SerializedModule Serialize();
 
   // If possible, deserialize the module, otherwise compile it from the provided
   // uncompiled bytes.
   static MaybeLocal<WasmCompiledModule> DeserializeOrCompile(
       Isolate* isolate, const CallerOwnedBuffer& serialized_module,
       const CallerOwnedBuffer& wire_bytes);
   V8_INLINE static WasmCompiledModule* Cast(Value* obj);
 
  private:
+  // TODO(ahaas): please remove the friend once streamed compilation is
+  // implemented
+  friend class WasmModuleObjectBuilder;
+
   static MaybeLocal<WasmCompiledModule> Deserialize(
       Isolate* isolate, const CallerOwnedBuffer& serialized_module,
       const CallerOwnedBuffer& wire_bytes);
   static MaybeLocal<WasmCompiledModule> Compile(Isolate* isolate,
                                                 const uint8_t* start,
                                                 size_t length);
   static CallerOwnedBuffer AsCallerOwned(
       const TransferrableModule::OwnedBuffer& buff) {
     return {buff.first.get(), buff.second};
   }
 
   WasmCompiledModule();
   static void CheckCast(Value* obj);
 };
 
+class V8_EXPORT WasmModuleObjectBuilder final {
+ public:
+  WasmModuleObjectBuilder(Isolate* isolate) : isolate_(isolate) {}
+  void OnBytesReceived(std::unique_ptr<const uint8_t[]>&& bytes, size_t size);
+  MaybeLocal<WasmCompiledModule> Finish();
+
+ private:
+  Isolate* isolate_ = nullptr;
+  // TODO(ahaas): We probably need none of this below here once streamed
+  // compilation is implemented.
+  typedef std::pair<std::unique_ptr<const uint8_t[]>, size_t> Buffer;
+
+  // Disable copy semantics *in this implementation*. We can choose to
+  // relax this, albeit it's not clear why.
+  WasmModuleObjectBuilder(const WasmModuleObjectBuilder&) = delete;
+  WasmModuleObjectBuilder(WasmModuleObjectBuilder&&) = default;
+  WasmModuleObjectBuilder& operator=(const WasmModuleObjectBuilder&) = delete;
+  WasmModuleObjectBuilder& operator=(WasmModuleObjectBuilder&&) = default;
+
+  std::vector<Buffer> received_buffers_;
+  size_t total_size_ = 0;
+};
+
 #ifndef V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT
 // The number of required internal fields can be defined by embedder.
 #define V8_ARRAY_BUFFER_INTERNAL_FIELD_COUNT 2
 #endif
 
 
 enum class ArrayBufferCreationMode { kInternalized, kExternalized };
 
 
 /**
@@ skipping 5895 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // INCLUDE_V8_H_