Update mojo sdk to rev 59145288bae55b0fce4276b017df6a1117bcf00f

mojo/edk/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/files/file_path.h"
 #include "base/files/file_util.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/test/test_io_thread.h"
 #include "base/threading/platform_thread.h"  // For |Sleep()|.
 #include "build/build_config.h"              // TODO(vtl): Remove this.
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
 #include "mojo/edk/system/channel_endpoint_id.h"
+#include "mojo/edk/system/incoming_endpoint.h"
 #include "mojo/edk/system/message_pipe.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/raw_channel.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
 #include "mojo/edk/system/test_utils.h"
 #include "mojo/edk/system/waiter.h"
 #include "mojo/edk/test/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 92 matching lines @@
 
   void BootstrapChannelEndpointsOnIOThread(scoped_refptr<ChannelEndpoint> ep0,
                                            scoped_refptr<ChannelEndpoint> ep1) {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
 
     if (!channels_[0])
       CreateAndInitChannel(0);
     if (!channels_[1])
       CreateAndInitChannel(1);
 
-    channels_[0]->AttachAndRunEndpoint(ep0, true);
-    channels_[1]->AttachAndRunEndpoint(ep1, true);
+    channels_[0]->SetBootstrapEndpoint(ep0);
+    channels_[1]->SetBootstrapEndpoint(ep1);
   }
 
   void BootstrapChannelEndpointOnIOThread(unsigned channel_index,
                                           scoped_refptr<ChannelEndpoint> ep) {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
     CHECK(channel_index == 0 || channel_index == 1);
 
     CreateAndInitChannel(channel_index);
-    channels_[channel_index]->AttachAndRunEndpoint(ep, true);
+    channels_[channel_index]->SetBootstrapEndpoint(ep);
   }
 
   void RestoreInitialStateOnIOThread() {
     CHECK_EQ(base::MessageLoop::current(), io_thread()->message_loop());
 
     TearDownOnIOThread();
     SetUpOnIOThread();
   }
 
   embedder::SimplePlatformSupport platform_support_;
@@ skipping 163 matching lines @@
   // Now put another message pipe on the channel.
 
   // Do this by creating a message pipe (for the |channels(0)| side) and
   // attaching and running it, yielding the remote ID. A message is then sent
   // via |ep0| (i.e., sent using |mp0|, port 0) with this remote ID. Upon
   // receiving this message, |PassIncomingMessagePipe()| is used to obtain the
   // message pipe on the other side.
   scoped_refptr<ChannelEndpoint> ep2;
   scoped_refptr<MessagePipe> mp2(MessagePipe::CreateLocalProxy(&ep2));
   ASSERT_TRUE(channels(0));
-  ChannelEndpointId remote_id = channels(0)->AttachAndRunEndpoint(ep2, false);
-  EXPECT_TRUE(remote_id.is_remote());
+  size_t endpoint_info_size = channels(0)->GetSerializedEndpointSize();
+  scoped_ptr<char[]> endpoint_info(new char[endpoint_info_size]);
+  channels(0)->SerializeEndpoint(ep2, endpoint_info.get());
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp1->AddAwakable(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0, UserPointer<const void>(&remote_id),
-                              sizeof(remote_id), nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+            mp0->WriteMessage(0, UserPointer<const void>(endpoint_info.get()),
+                              static_cast<uint32_t>(endpoint_info_size),
+                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
   hss = HandleSignalsState();
   mp1->RemoveAwakable(1, &waiter, &hss);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(kAllSignals, hss.satisfiable_signals);
 
-  ChannelEndpointId received_id;
-  buffer_size = static_cast<uint32_t>(sizeof(received_id));
+  EXPECT_EQ(endpoint_info_size, channels(1)->GetSerializedEndpointSize());
+  scoped_ptr<char[]> received_endpoint_info(new char[endpoint_info_size]);
+  buffer_size = static_cast<uint32_t>(endpoint_info_size);
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1, UserPointer<void>(&received_id),
+            mp1->ReadMessage(1, UserPointer<void>(received_endpoint_info.get()),
                              MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(sizeof(received_id), static_cast<size_t>(buffer_size));
-  EXPECT_EQ(remote_id, received_id);
+  EXPECT_EQ(endpoint_info_size, static_cast<size_t>(buffer_size));
+  EXPECT_EQ(0, memcmp(received_endpoint_info.get(), endpoint_info.get(),
+                      endpoint_info_size));
 
   // Warning: The local side of mp3 is port 0, not port 1.
-  scoped_refptr<MessagePipe> mp3 =
-      channels(1)->PassIncomingMessagePipe(received_id);
+  scoped_refptr<IncomingEndpoint> incoming_endpoint =
+      channels(1)->DeserializeEndpoint(received_endpoint_info.get());
+  ASSERT_TRUE(incoming_endpoint);
+  scoped_refptr<MessagePipe> mp3 = incoming_endpoint->ConvertToMessagePipe();
   ASSERT_TRUE(mp3);
 
   // Write: MP 2, port 0 -> MP 3, port 1.
 
   waiter.Init();
   ASSERT_EQ(
       MOJO_RESULT_OK,
       mp3->AddAwakable(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
 
   EXPECT_EQ(
@@ skipping 975 matching lines @@
   mp0->Close(0);
   mp1->Close(1);
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
   // Note that |local_mp|'s port 0 belong to |dispatcher|, which was closed.
   local_mp->Close(1);
 }
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo