Mojo: Add static factory functions to MessagePipe.

mojo/system/remote_message_pipe_unittest.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 <stdint.h>
 #include <stdio.h>
 #include <string.h>
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "build/build_config.h"              // TODO(vtl): Remove this.
 #include "mojo/common/test/test_utils.h"
 #include "mojo/embedder/platform_channel_pair.h"
 #include "mojo/embedder/platform_shared_buffer.h"
 #include "mojo/embedder/scoped_platform_handle.h"
 #include "mojo/embedder/simple_platform_support.h"
 #include "mojo/system/channel.h"
-#include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/message_pipe.h"
 #include "mojo/system/message_pipe_dispatcher.h"
 #include "mojo/system/platform_handle_dispatcher.h"
-#include "mojo/system/proxy_message_pipe_endpoint.h"
 #include "mojo/system/raw_channel.h"
 #include "mojo/system/shared_buffer_dispatcher.h"
 #include "mojo/system/test_utils.h"
 #include "mojo/system/waiter.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace system {
 namespace {
 
@@ skipping 143 matching lines @@
   char buffer[100] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
-  scoped_refptr<MessagePipe> mp0(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipe> mp1(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));
+  scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
   ConnectMessagePipes(mp0, mp1);
 
   // Write in one direction: MP 0, port 0 -> ... -> MP 1, port 1.
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, NULL));
 
@@ skipping 87 matching lines @@
   static const char kHello[] = "hello";
   static const char kWorld[] = "world!!!1!!!1!";
   char buffer[100] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes as in the |Basic| test.
 
-  scoped_refptr<MessagePipe> mp0(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipe> mp1(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));
+  scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
   ConnectMessagePipes(mp0, mp1);
 
   // Now put another message pipe on the channel.
 
-  scoped_refptr<MessagePipe> mp2(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipe> mp3(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp2(new MessagePipe(MessagePipe::LocalProxy()));
+  scoped_refptr<MessagePipe> mp3(new MessagePipe(MessagePipe::ProxyLocal()));
   ConnectMessagePipes(mp2, mp3);
 
   // Write: MP 2, port 0 -> MP 3, port 1.
 
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp3->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, NULL));
 
   EXPECT_EQ(MOJO_RESULT_OK,
             mp2->WriteMessage(0,
@@ skipping 119 matching lines @@
   char buffer[100] = {0};
   uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
   // Connect message pipes. MP 0, port 1 will be attached to channel 0 and
   // connected to MP 1, port 0, which will be attached to channel 1. This leaves
   // MP 0, port 0 and MP 1, port 1 as the "user-facing" endpoints.
 
-  scoped_refptr<MessagePipe> mp0(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));
 
   // Write to MP 0, port 0.
   EXPECT_EQ(MOJO_RESULT_OK,
             mp0->WriteMessage(0,
                               UserPointer<const void>(kHello),
                               sizeof(kHello),
                               NULL,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   BootstrapMessagePipeNoWait(0, mp0);
 
   // Close MP 0, port 0 before channel 1 is even connected.
   mp0->Close(0);
 
-  scoped_refptr<MessagePipe> mp1(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, NULL));
 
   BootstrapMessagePipeNoWait(1, mp1);
 
   // Wait.
@@ skipping 22 matching lines @@
   // And MP 1, port 1.
   mp1->Close(1);
 }
 
 TEST_F(RemoteMessagePipeTest, HandlePassing) {
   static const char kHello[] = "hello";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
-  scoped_refptr<MessagePipe> mp0(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipe> mp1(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));

[darin (slow to review), 2014/08/25 21:56:58]

Had you considered a static constructor like MessagePipe::CreateLocalProxy()?
That would avoid the repeating of MessagePipe in the above line.

It looks like all constructor calls are heap allocations of the form "new
MessagePipe(MessagePipe::Blah)"

+  scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
   ConnectMessagePipes(mp0, mp1);
 
   // We'll try to pass this dispatcher.
   scoped_refptr<MessagePipeDispatcher> dispatcher(
       new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions));
-  scoped_refptr<MessagePipe> local_mp(new MessagePipe());
+  scoped_refptr<MessagePipe> local_mp(
+      new MessagePipe(MessagePipe::LocalLocal()));
   dispatcher->Init(local_mp, 0);
 
   // Prepare to wait on MP 1, port 1. (Add the waiter now. Otherwise, if we do
   // it later, it might already be readable.)
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, NULL));
 
   // Write to MP 0, port 0.
   {
@@ skipping 140 matching lines @@
 #else
 // Not yet implemented (on Windows).
 #define MAYBE_SharedBufferPassing DISABLED_SharedBufferPassing
 #endif
 TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) {
   static const char kHello[] = "hello";
   Waiter waiter;
   HandleSignalsState hss;
   uint32_t context = 0;
 
-  scoped_refptr<MessagePipe> mp0(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipe> mp1(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));
+  scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
   ConnectMessagePipes(mp0, mp1);
 
   // We'll try to pass this dispatcher.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
   EXPECT_EQ(MOJO_RESULT_OK,
             SharedBufferDispatcher::Create(
                 platform_support(),
                 SharedBufferDispatcher::kDefaultCreateOptions,
                 100,
                 &dispatcher));
@@ skipping 112 matching lines @@
 TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) {
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
 
   static const char kHello[] = "hello";
   static const char kWorld[] = "world";
   Waiter waiter;
   uint32_t context = 0;
   HandleSignalsState hss;
 
-  scoped_refptr<MessagePipe> mp0(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipe> mp1(new MessagePipe(
-      scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-      scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+  scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));
+  scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
   ConnectMessagePipes(mp0, mp1);
 
   base::FilePath unused;
   base::ScopedFILE fp(
       CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
   EXPECT_EQ(sizeof(kHello), fwrite(kHello, 1, sizeof(kHello), fp.get()));
   // We'll try to pass this dispatcher, which will cause a |PlatformHandle| to
   // be passed.
   scoped_refptr<PlatformHandleDispatcher> dispatcher(
       new PlatformHandleDispatcher(
@@ skipping 81 matching lines @@
 
 // Test racing closes (on each end).
 // Note: A flaky failure would almost certainly indicate a problem in the code
 // itself (not in the test). Also, any logged warnings/errors would also
 // probably be indicative of bugs.
 TEST_F(RemoteMessagePipeTest, RacingClosesStress) {
   base::TimeDelta delay = base::TimeDelta::FromMilliseconds(5);
 
   for (unsigned i = 0; i < 256; i++) {
     DVLOG(2) << "---------------------------------------- " << i;
-    scoped_refptr<MessagePipe> mp0(new MessagePipe(
-        scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
-        scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
+    scoped_refptr<MessagePipe> mp0(new MessagePipe(MessagePipe::LocalProxy()));
     BootstrapMessagePipeNoWait(0, mp0);
 
-    scoped_refptr<MessagePipe> mp1(new MessagePipe(
-        scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint()),
-        scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint())));
+    scoped_refptr<MessagePipe> mp1(new MessagePipe(MessagePipe::ProxyLocal()));
     BootstrapMessagePipeNoWait(1, mp1);
 
     if (i & 1u) {
       io_thread()->task_runner()->PostTask(
           FROM_HERE, base::Bind(&base::PlatformThread::Sleep, delay));
     }
     if (i & 2u)
       base::PlatformThread::Sleep(delay);
 
     mp0->Close(0);
 
     if (i & 4u) {
       io_thread()->task_runner()->PostTask(
           FROM_HERE, base::Bind(&base::PlatformThread::Sleep, delay));
     }
     if (i & 8u)
       base::PlatformThread::Sleep(delay);
 
     mp1->Close(1);
 
     RestoreInitialState();
   }
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo