Add support for MojoCreateMessagePipeOptions struct to JS bindings

mojo/bindings/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/bindings/js/core.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
@@ skipping 26 matching lines @@
 }
 
 MojoResult WaitMany(
     const std::vector<mojo::Handle>& handles,
     const std::vector<MojoHandleSignals>& signals,
     MojoDeadline deadline) {
   return mojo::WaitMany(handles, signals, deadline);
 }
 
 gin::Dictionary CreateMessagePipe(const gin::Arguments& args) {
+  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
+  dictionary.Set("result", MOJO_RESULT_INVALID_ARGUMENT);
+
   MojoHandle handle0 = MOJO_HANDLE_INVALID;
   MojoHandle handle1 = MOJO_HANDLE_INVALID;
-  // TODO(vtl): Add support for the options struct.
-  MojoResult result = MojoCreateMessagePipe(NULL, &handle0, &handle1);
-  CHECK(result == MOJO_RESULT_OK);
+  MojoResult result = MOJO_RESULT_OK;
 
-  gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
+  v8::Handle<v8::Value> options_value = args.PeekNext();
+  if (options_value.IsEmpty() || options_value->IsNull() ||
+      options_value->IsUndefined()) {
+    result = MojoCreateMessagePipe(NULL, &handle0, &handle1);
+  } else if (options_value->IsObject()) {
+    gin::Dictionary options_dict(args.isolate(), options_value->ToObject());
+    MojoCreateMessagePipeOptions options;
+    // For future struct_size, we can probably infer that from the presence of
+    // properties in options_dict. For now, it's always 8.
+    options.struct_size = 8;
+    // Ideally these would be optional. But the interface makes it hard to
+    // typecheck them then.
+    if (!options_dict.Get("flags", &options.flags)) {
+      return dictionary;
+    }
+
+    result = MojoCreateMessagePipe(&options, &handle0, &handle1);
+  } else {
+      return dictionary;
+  }
+
+  CHECK_EQ(MOJO_RESULT_OK, result);
+
+  dictionary.Set("result", result);
   dictionary.Set("handle0", mojo::Handle(handle0));
   dictionary.Set("handle1", mojo::Handle(handle1));
   return dictionary;
 }
 
 MojoResult WriteMessage(
     mojo::Handle handle,
     const gin::ArrayBufferView& buffer,
     const std::vector<gin::Handle<gin::HandleWrapper> >& handles,
     MojoWriteMessageFlags flags) {
@@ skipping 47 matching lines @@
   CHECK(buffer.num_bytes() == num_bytes);
   CHECK(handles.size() == num_handles);
 
   gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
   dictionary.Set("result", result);
   dictionary.Set("buffer", array_buffer);
   dictionary.Set("handles", handles);
   return dictionary;
 }
 
-gin::Dictionary CreateDataPipe(const gin::Arguments& args,
-                               v8::Handle<v8::Value> options_value) {
+gin::Dictionary CreateDataPipe(const gin::Arguments& args) {
   gin::Dictionary dictionary = gin::Dictionary::CreateEmpty(args.isolate());
   dictionary.Set("result", MOJO_RESULT_INVALID_ARGUMENT);
 
   MojoHandle producer_handle = MOJO_HANDLE_INVALID;
   MojoHandle consumer_handle = MOJO_HANDLE_INVALID;
   MojoResult result = MOJO_RESULT_OK;
 
-  if (options_value->IsObject()) {
+  v8::Handle<v8::Value> options_value = args.PeekNext();
+  if (options_value.IsEmpty() || options_value->IsNull() ||
+      options_value->IsUndefined()) {
+    result = MojoCreateDataPipe(NULL, &producer_handle, &consumer_handle);
+  } else if (options_value->IsObject()) {
     gin::Dictionary options_dict(args.isolate(), options_value->ToObject());
     MojoCreateDataPipeOptions options;
     // For future struct_size, we can probably infer that from the presence of
     // properties in options_dict. For now, it's always 16.
     options.struct_size = 16;
     // Ideally these would be optional. But the interface makes it hard to
     // typecheck them then.
     if (!options_dict.Get("flags", &options.flags) ||
         !options_dict.Get("elementNumBytes", &options.element_num_bytes) ||
         !options_dict.Get("capacityNumBytes", &options.capacity_num_bytes)) {
       return dictionary;
     }
 
     result = MojoCreateDataPipe(&options, &producer_handle, &consumer_handle);
-  } else if (options_value->IsNull() || options_value->IsUndefined()) {
-    result = MojoCreateDataPipe(NULL, &producer_handle, &consumer_handle);
   } else {
     return dictionary;
   }
 
   CHECK_EQ(MOJO_RESULT_OK, result);
 
   dictionary.Set("result", result);
   dictionary.Set("producerHandle", mojo::Handle(producer_handle));
   dictionary.Set("consumerHandle", mojo::Handle(consumer_handle));
   return dictionary;
@@ skipping 82 matching lines @@
         .SetValue("RESULT_DATA_LOSS", MOJO_RESULT_DATA_LOSS)
         .SetValue("RESULT_BUSY", MOJO_RESULT_BUSY)
         .SetValue("RESULT_SHOULD_WAIT", MOJO_RESULT_SHOULD_WAIT)
 
         .SetValue("DEADLINE_INDEFINITE", MOJO_DEADLINE_INDEFINITE)
 
         .SetValue("HANDLE_SIGNAL_NONE", MOJO_HANDLE_SIGNAL_NONE)
         .SetValue("HANDLE_SIGNAL_READABLE", MOJO_HANDLE_SIGNAL_READABLE)
         .SetValue("HANDLE_SIGNAL_WRITABLE", MOJO_HANDLE_SIGNAL_WRITABLE)
 
+        .SetValue("CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE",
+                  MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE)
+
         .SetValue("WRITE_MESSAGE_FLAG_NONE", MOJO_WRITE_MESSAGE_FLAG_NONE)
 
         .SetValue("READ_MESSAGE_FLAG_NONE", MOJO_READ_MESSAGE_FLAG_NONE)
         .SetValue("READ_MESSAGE_FLAG_MAY_DISCARD",
                   MOJO_READ_MESSAGE_FLAG_MAY_DISCARD)
 
         .SetValue("CREATE_DATA_PIPE_OPTIONS_FLAG_NONE",
                   MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE)
         .SetValue("CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD",
                   MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD)
@@ skipping 10 matching lines @@
         .Build();
 
     data->SetObjectTemplate(&g_wrapper_info, templ);
   }
 
   return templ->NewInstance();
 }
 
 }  // namespace js
 }  // namespace mojo