Mojo: Add a MojoCreateMessagePipeOptions struct parameter to MojoCreateMessagePipe.

mojo/system/message_pipe_dispatcher_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.
 
 // NOTE(vtl): Some of these tests are inherently flaky (e.g., if run on a
 // heavily-loaded system). Sorry. |test::EpsilonTimeout()| may be increased to
 // increase tolerance and reduce observed flakiness (though doing so reduces the
 // meaningfulness of the test).
 
 #include "mojo/system/message_pipe_dispatcher.h"
@@ skipping 19 matching lines @@
 namespace {
 
 TEST(MessagePipeDispatcherTest, Basic) {
   test::Stopwatch stopwatch;
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher());
+    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
     EXPECT_EQ(Dispatcher::kTypeMessagePipe, d0->GetType());
-    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher());
+    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
     {
       scoped_refptr<MessagePipe> mp(new MessagePipe());
       d0->Init(mp, i);  // 0, 1.
       d1->Init(mp, i ^ 1);  // 1, 0.
     }
     Waiter w;
 
     // Try adding a writable waiter when already writable.
     w.Init();
     EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
@@ skipping 53 matching lines @@
     d0->RemoveWaiter(&w);
 
     EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
     EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
   }
 }
 
 TEST(MessagePipeDispatcherTest, InvalidParams) {
   char buffer[1];
 
-  scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher());
-  scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher());
+  scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+  scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
   {
     scoped_refptr<MessagePipe> mp(new MessagePipe());
     d0->Init(mp, 0);
     d1->Init(mp, 1);
   }
 
   // |WriteMessage|:
   // Null buffer with nonzero buffer size.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             d0->WriteMessage(NULL, 1,
@@ skipping 18 matching lines @@
 }
 
 // Test what happens when one end is closed (single-threaded test).
 TEST(MessagePipeDispatcherTest, BasicClosed) {
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher());
-    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher());
+    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
     {
       scoped_refptr<MessagePipe> mp(new MessagePipe());
       d0->Init(mp, i);  // 0, 1.
       d1->Init(mp, i ^ 1);  // 1, 0.
     }
     Waiter w;
 
     // Write (twice) to |d1|.
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
@@ skipping 86 matching lines @@
   test::Stopwatch stopwatch;
   int32_t buffer[1];
   const uint32_t kBufferSize = static_cast<uint32_t>(sizeof(buffer));
   uint32_t buffer_size;
   base::TimeDelta elapsed;
   bool did_wait;
   MojoResult result;
 
   // Run this test both with |d0| as port 0, |d1| as port 1 and vice versa.
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher());
-    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher());
+    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
     {
       scoped_refptr<MessagePipe> mp(new MessagePipe());
       d0->Init(mp, i);  // 0, 1.
       d1->Init(mp, i ^ 1);  // 1, 0.
     }
 
     // Wait for readable on |d1|, which will become readable after some time.
     {
       test::WaiterThread thread(d1,
                                MOJO_WAIT_FLAG_READABLE,
@@ skipping 56 matching lines @@
     elapsed = stopwatch.Elapsed();
     EXPECT_GT(elapsed, (2-1) * test::EpsilonTimeout());
     EXPECT_LT(elapsed, (2+1) * test::EpsilonTimeout());
     EXPECT_TRUE(did_wait);
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
 
     EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
   }
 
   for (unsigned i = 0; i < 2; i++) {
-    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher());
-    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher());
+    scoped_refptr<MessagePipeDispatcher> d0(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+    scoped_refptr<MessagePipeDispatcher> d1(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
     {
       scoped_refptr<MessagePipe> mp(new MessagePipe());
       d0->Init(mp, i);  // 0, 1.
       d1->Init(mp, i ^ 1);  // 1, 0.
     }
 
     // Wait for readable on |d1| and close |d1| after some time, which should
     // cancel that wait.
     {
       test::WaiterThread thread(d1,
@@ skipping 152 matching lines @@
   size_t* const messages_read_;
   size_t* const bytes_read_;
 
   DISALLOW_COPY_AND_ASSIGN(ReaderThread);
 };
 
 TEST(MessagePipeDispatcherTest, Stress) {
   static const size_t kNumWriters = 30;
   static const size_t kNumReaders = kNumWriters;
 
-  scoped_refptr<MessagePipeDispatcher> d_write(new MessagePipeDispatcher());
-  scoped_refptr<MessagePipeDispatcher> d_read(new MessagePipeDispatcher());
+  scoped_refptr<MessagePipeDispatcher> d_write(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
+  scoped_refptr<MessagePipeDispatcher> d_read(new MessagePipeDispatcher(
+        MessagePipeDispatcher::kDefaultCreateOptions));
   {
     scoped_refptr<MessagePipe> mp(new MessagePipe());
     d_write->Init(mp, 0);
     d_read->Init(mp, 1);
   }
 
   size_t messages_written[kNumWriters];
   size_t bytes_written[kNumWriters];
   size_t messages_read[kNumReaders];
   size_t bytes_read[kNumReaders];
@@ skipping 43 matching lines @@
   EXPECT_EQ(total_messages_written, total_messages_read);
   EXPECT_EQ(total_bytes_written, total_bytes_read);
 
   EXPECT_EQ(MOJO_RESULT_OK, d_write->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d_read->Close());
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo