Add Mojo{Set,Get}DataPipeProducerOptions() to the NaCl system thunks.

mojo/public/c/system/tests/core_unittest.cc

 // Copyright 2013 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.
 
 // This file tests the C API.
 
 #include <string.h>
 
 #include "mojo/public/c/system/buffer.h"
 #include "mojo/public/c/system/data_pipe.h"
@@ skipping 45 matching lines @@
   // Message pipe:
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoWriteMessage(MOJO_HANDLE_INVALID, buffer, 0u, nullptr, 0u,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoReadMessage(MOJO_HANDLE_INVALID, buffer, &buffer_size, nullptr,
                             nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Data pipe:
+  MojoDataPipeProducerOptions dpp_options = {
+      sizeof(MojoDataPipeProducerOptions), 0u};
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoSetDataPipeProducerOptions(MOJO_HANDLE_INVALID, &dpp_options));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            MojoGetDataPipeProducerOptions(
+                MOJO_HANDLE_INVALID, &dpp_options,
+                static_cast<uint32_t>(sizeof(dpp_options))));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoWriteData(MOJO_HANDLE_INVALID, buffer, &buffer_size,
                           MOJO_WRITE_DATA_FLAG_NONE));
   write_pointer = nullptr;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoBeginWriteData(MOJO_HANDLE_INVALID, &write_pointer,
                                &buffer_size, MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             MojoEndWriteData(MOJO_HANDLE_INVALID, 1u));
@@ skipping 234 matching lines @@
             MojoWait(hc, MOJO_HANDLE_SIGNAL_READABLE, 1000, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hc));
 
   // TODO(vtl): Test the other way around -- closing the consumer should make
   // the producer never-writable?
 }
 
-// TODO(vtl): Enable once I've added support for NaCl.
-#ifndef __native_client__
 TEST(CoreTest, DataPipeWriteThreshold) {
   const MojoCreateDataPipeOptions options = {
       static_cast<uint32_t>(
           sizeof(MojoCreateDataPipeOptions)),   // |struct_size|.
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,  // |flags|.
       2u,                                       // |element_num_bytes|.
       4u                                        // |capacity_num_bytes|.
   };
   MojoHandle hp = MOJO_HANDLE_INVALID;
   MojoHandle hc = MOJO_HANDLE_INVALID;
@@ skipping 38 matching lines @@
   static const uint16_t kTestElem = 12345u;
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK, MojoWriteData(hp, &kTestElem, &num_bytes,
                                           MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(2u, num_bytes);
 
   // Should still have the write threshold signal.
   EXPECT_EQ(MOJO_RESULT_OK,
             MojoWait(hp, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, nullptr));
 
-  // Do a two-phase write of another element.
-  void* write_pointer = nullptr;
-  num_bytes = 0u;
-  EXPECT_EQ(MOJO_RESULT_OK, MojoBeginWriteData(hp, &write_pointer, &num_bytes,
-                                               MOJO_WRITE_DATA_FLAG_NONE));
-  ASSERT_TRUE(write_pointer);
-  ASSERT_EQ(2u, num_bytes);
-  *static_cast<uint16_t*>(write_pointer) = 6789u;
-  EXPECT_EQ(MOJO_RESULT_OK, MojoEndWriteData(hp, 2u));
+  // Write another element.
+  static const uint16_t kAnotherTestElem = 12345u;
+  num_bytes = 2u;
+  EXPECT_EQ(MOJO_RESULT_OK, MojoWriteData(hp, &kAnotherTestElem, &num_bytes,
+                                          MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(2u, num_bytes);
 
   // Should no longer have the write threshold signal.
   state = MojoHandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
             MojoWait(hp, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, &state));
   EXPECT_EQ(0u, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE | MOJO_HANDLE_SIGNAL_PEER_CLOSED |
                 MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD,
             state.satisfiable_signals);
 
@@ skipping 44 matching lines @@
 
   // The write threshold signal should now be unsatisfiable.
   state = MojoHandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             MojoWait(hp, MOJO_HANDLE_SIGNAL_WRITE_THRESHOLD, 0, &state));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_PEER_CLOSED, state.satisfiable_signals);
 
   EXPECT_EQ(MOJO_RESULT_OK, MojoClose(hp));
 }
-#endif
 
 TEST(CoreTest, DataPipeReadThreshold) {
   MojoHandle hp = MOJO_HANDLE_INVALID;
   MojoHandle hc = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK, MojoCreateDataPipe(nullptr, &hp, &hc));
   EXPECT_NE(hp, MOJO_HANDLE_INVALID);
   EXPECT_NE(hc, MOJO_HANDLE_INVALID);
   EXPECT_NE(hc, hp);
 
   MojoDataPipeConsumerOptions copts;
@@ skipping 177 matching lines @@
 
 TEST(CoreTest, MinimalCppTest) {
   const char* failure = MinimalCppTest();
   EXPECT_FALSE(failure) << failure;
 }
 
 // TODO(vtl): Add multi-threaded tests.
 
 }  // namespace
 }  // namespace mojo