[mojo] Add shared buffer support to mojo JavaScript bindings.

mojo/edk/js/core.cc

 // 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 "mojo/edk/js/core.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/bind.h"
@@ skipping 271 matching lines @@
                                   gin::Handle<HandleWrapper> handle) {
   return (new DrainData(args->isolate(), handle->release()))->GetPromise();
 }
 
 bool IsHandle(gin::Arguments* args, v8::Handle<v8::Value> val) {
   gin::Handle<mojo::edk::js::HandleWrapper> ignore_handle;
   return gin::Converter<gin::Handle<mojo::edk::js::HandleWrapper>>::FromV8(
       args->isolate(), val, &ignore_handle);
 }
 
+gin::Dictionary CreateSharedBuffer(const gin::Arguments& args,
+                                   uint64_t num_bytes,
+                                   MojoCreateSharedBufferOptionsFlags flags) {
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
+  MojoHandle handle = MOJO_HANDLE_INVALID;
+  MojoCreateSharedBufferOptions options;
+  options.flags = flags;
+  MojoResult result = MojoCreateSharedBuffer(&options, num_bytes, &handle);
+  if (result != MOJO_RESULT_OK) {
+    dictionary.Set("result", result);
+    return dictionary;
+  }
+
+  dictionary.Set("result", result);
+  dictionary.Set("handle", mojo::Handle(handle));
+
+  return dictionary;
+}
+
+gin::Dictionary DuplicateBufferHandle(
+    const gin::Arguments& args,
+    mojo::Handle handle,
+    MojoDuplicateBufferHandleOptionsFlags flags) {
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
+  MojoHandle duped = MOJO_HANDLE_INVALID;
+  MojoDuplicateBufferHandleOptions options;
+  // The |flags| is mandatory parameter for DuplicateBufferHandle, and it will
+  // be always initialized in MojoDuplicateBufferHandleOptions struct. For now,
+  // since the struct has only one options field (flags), set struct_size to be
+  // equal to the size of MojoDuplicateBufferHandleOptions.
+  options.struct_size =
+      static_cast<uint32_t>(sizeof(MojoDuplicateBufferHandleOptions));
+  options.flags = flags;
+  MojoResult result =
+      MojoDuplicateBufferHandle(handle.value(), &options, &duped);
+  if (result != MOJO_RESULT_OK) {
+    dictionary.Set("result", result);
+    return dictionary;
+  }
+
+  dictionary.Set("result", result);
+  dictionary.Set("handle", mojo::Handle(duped));
+
+  return dictionary;
+}
+
+gin::Dictionary MapBuffer(const gin::Arguments& args,
+                          mojo::Handle handle,
+                          uint64_t offset,
+                          uint64_t num_bytes,
+                          MojoMapBufferFlags flags) {
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
+  void* data = nullptr;
+  MojoResult result =
+      MojoMapBuffer(handle.value(), offset, num_bytes, &data, flags);
+  if (result != MOJO_RESULT_OK) {
+    dictionary.Set("result", result);
+    return dictionary;
+  }
+
+  v8::Handle<v8::ArrayBuffer> array_buffer =
+      v8::ArrayBuffer::New(args.isolate(), data, num_bytes);
+
+  dictionary.Set("result", result);
+  dictionary.Set("buffer", array_buffer);
+
+  return dictionary;
+}
+
+MojoResult UnmapBuffer(const gin::Arguments& args,
+                       const v8::Handle<v8::ArrayBuffer>& buffer) {
+  // Buffer must be external, created by MapBuffer
+  if (!buffer->IsExternal())
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+  return MojoUnmapBuffer(buffer->GetContents().Data());
+}
 
 gin::WrapperInfo g_wrapper_info = { gin::kEmbedderNativeGin };
 
 }  // namespace
 
 const char Core::kModuleName[] = "mojo/public/js/core";
 
 v8::Local<v8::Value> Core::GetModule(v8::Isolate* isolate) {
   gin::PerIsolateData* data = gin::PerIsolateData::From(isolate);
   v8::Local<v8::ObjectTemplate> templ = data->GetObjectTemplate(
       &g_wrapper_info);
 
   if (templ.IsEmpty()) {
     templ =
         gin::ObjectTemplateBuilder(isolate)
             // TODO(mpcomplete): Should these just be methods on the JS Handle
             // object?
             .SetMethod("close", CloseHandle)
             .SetMethod("wait", WaitHandle)
             .SetMethod("waitMany", WaitMany)
             .SetMethod("createMessagePipe", CreateMessagePipe)
             .SetMethod("writeMessage", WriteMessage)
             .SetMethod("readMessage", ReadMessage)
             .SetMethod("createDataPipe", CreateDataPipe)
             .SetMethod("writeData", WriteData)
             .SetMethod("readData", ReadData)
             .SetMethod("drainData", DoDrainData)
             .SetMethod("isHandle", IsHandle)
+            .SetMethod("createSharedBuffer", CreateSharedBuffer)
+            .SetMethod("duplicateBufferHandle", DuplicateBufferHandle)
+            .SetMethod("mapBuffer", MapBuffer)
+            .SetMethod("unmapBuffer", UnmapBuffer)
 
             .SetValue("RESULT_OK", MOJO_RESULT_OK)
             .SetValue("RESULT_CANCELLED", MOJO_RESULT_CANCELLED)
             .SetValue("RESULT_UNKNOWN", MOJO_RESULT_UNKNOWN)
             .SetValue("RESULT_INVALID_ARGUMENT", MOJO_RESULT_INVALID_ARGUMENT)
             .SetValue("RESULT_DEADLINE_EXCEEDED", MOJO_RESULT_DEADLINE_EXCEEDED)
             .SetValue("RESULT_NOT_FOUND", MOJO_RESULT_NOT_FOUND)
             .SetValue("RESULT_ALREADY_EXISTS", MOJO_RESULT_ALREADY_EXISTS)
             .SetValue("RESULT_PERMISSION_DENIED", MOJO_RESULT_PERMISSION_DENIED)
             .SetValue("RESULT_RESOURCE_EXHAUSTED",
@@ skipping 32 matching lines @@
             .SetValue("WRITE_DATA_FLAG_NONE", MOJO_WRITE_DATA_FLAG_NONE)
             .SetValue("WRITE_DATA_FLAG_ALL_OR_NONE",
                       MOJO_WRITE_DATA_FLAG_ALL_OR_NONE)
 
             .SetValue("READ_DATA_FLAG_NONE", MOJO_READ_DATA_FLAG_NONE)
             .SetValue("READ_DATA_FLAG_ALL_OR_NONE",
                       MOJO_READ_DATA_FLAG_ALL_OR_NONE)
             .SetValue("READ_DATA_FLAG_DISCARD", MOJO_READ_DATA_FLAG_DISCARD)
             .SetValue("READ_DATA_FLAG_QUERY", MOJO_READ_DATA_FLAG_QUERY)
             .SetValue("READ_DATA_FLAG_PEEK", MOJO_READ_DATA_FLAG_PEEK)
+            .SetValue("CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE",
+                      MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE)
+
+            .SetValue("DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE",
+                      MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_NONE)
+
+            .SetValue("DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_READ_ONLY",
+                      MOJO_DUPLICATE_BUFFER_HANDLE_OPTIONS_FLAG_READ_ONLY)
+
+            .SetValue("MAP_BUFFER_FLAG_NONE", MOJO_MAP_BUFFER_FLAG_NONE)
             .Build();
 
     data->SetObjectTemplate(&g_wrapper_info, templ);
   }
 
   return templ->NewInstance();
 }
 
 }  // namespace js
 }  // namespace edk
 }  // namespace mojo