Mojo: Remove Channel::AttachMessagePipeEndpoint().

mojo/system/channel_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 "mojo/system/channel.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/test_io_thread.h"
 #include "mojo/embedder/platform_channel_pair.h"
 #include "mojo/embedder/simple_platform_support.h"
+#include "mojo/system/channel_endpoint.h"
 #include "mojo/system/message_in_transit.h"
 #include "mojo/system/message_pipe.h"
 #include "mojo/system/raw_channel.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 165 matching lines @@
                                           base::Unretained(this)));
   ASSERT_TRUE(channel());
 
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this)));
   EXPECT_EQ(TRISTATE_TRUE, init_result());
 
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy());
 
-  MessageInTransit::EndpointId local_id =
-      channel()->AttachMessagePipeEndpoint(mp, 1);
+  MessageInTransit::EndpointId local_id = channel()->AttachEndpoint(
+      make_scoped_refptr(new ChannelEndpoint(mp.get(), 1)));
   EXPECT_EQ(Channel::kBootstrapEndpointId, local_id);
 
   mp->Close(0);
 
   // TODO(vtl): Currently, the |Close()| above won't detach (since it thinks
   // we're still expecting a "run" message from the other side), so the
   // |RunMessagePipeEndpoint()| below will return true. We need to refactor
-  // |AttachMessagePipeEndpoint()| to indicate whether |Run...()| will
-  // necessarily be called or not. (Then, in the case that it may not be called,
-  // this will return false.)
+  // |AttachEndpoint()| to indicate whether |Run...()| will necessarily be
+  // called or not. (Then, in the case that it may not be called, this will
+  // return false.)
   EXPECT_TRUE(channel()->RunMessagePipeEndpoint(local_id,
                                                 Channel::kBootstrapEndpointId));
 
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
                  base::Unretained(this)));
 
   EXPECT_TRUE(channel()->HasOneRef());
 }
 
 // ChannelTest.ShutdownAfterAttachAndRun ---------------------------------------
 
 TEST_F(ChannelTest, ShutdownAfterAttach) {
   io_thread()->PostTaskAndWait(FROM_HERE,
                                base::Bind(&ChannelTest::CreateChannelOnIOThread,
                                           base::Unretained(this)));
   ASSERT_TRUE(channel());
 
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this)));
   EXPECT_EQ(TRISTATE_TRUE, init_result());
 
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy());
 
-  MessageInTransit::EndpointId local_id =
-      channel()->AttachMessagePipeEndpoint(mp, 1);
+  MessageInTransit::EndpointId local_id = channel()->AttachEndpoint(
+      make_scoped_refptr(new ChannelEndpoint(mp.get(), 1)));
   EXPECT_EQ(Channel::kBootstrapEndpointId, local_id);
 
   // TODO(vtl): Currently, we always "expect" a |RunMessagePipeEndpoint()| after
-  // an |AttachMessagePipeEndpoint()| (which is actually incorrect). We need to
-  // refactor |AttachMessagePipeEndpoint()| to indicate whether |Run...()| will
-  // necessarily be called or not. (Then, in the case that it may not be called,
-  // we should test a |Shutdown()| without the |Run...()|.)
+  // an |AttachEndpoint()| (which is actually incorrect). We need to refactor
+  // |AttachEndpoint()| to indicate whether |Run...()| will necessarily be
+  // called or not. (Then, in the case that it may not be called, we should test
+  // a |Shutdown()| without the |Run...()|.)
   EXPECT_TRUE(channel()->RunMessagePipeEndpoint(local_id,
                                                 Channel::kBootstrapEndpointId));
 
   Waiter waiter;
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
             mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, NULL));
 
   // Don't wait for the shutdown to run ...
   io_thread()->PostTask(FROM_HERE,
@@ skipping 21 matching lines @@
                                           base::Unretained(this)));
   ASSERT_TRUE(channel());
 
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&ChannelTest::InitChannelOnIOThread, base::Unretained(this)));
   EXPECT_EQ(TRISTATE_TRUE, init_result());
 
   scoped_refptr<MessagePipe> mp(MessagePipe::CreateLocalProxy());
 
-  MessageInTransit::EndpointId local_id =
-      channel()->AttachMessagePipeEndpoint(mp, 1);
+  MessageInTransit::EndpointId local_id = channel()->AttachEndpoint(
+      make_scoped_refptr(new ChannelEndpoint(mp.get(), 1)));
   EXPECT_EQ(Channel::kBootstrapEndpointId, local_id);
 
   EXPECT_TRUE(channel()->RunMessagePipeEndpoint(local_id,
                                                 Channel::kBootstrapEndpointId));
 
   io_thread()->PostTaskAndWait(
       FROM_HERE,
       base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
                  base::Unretained(this)));
 
   Waiter waiter;
   waiter.Init();
   HandleSignalsState hss;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, &hss));
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   mp->Close(0);
 
   EXPECT_TRUE(channel()->HasOneRef());
 }
 
 // TODO(vtl): More. ------------------------------------------------------------
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo