Update mojo sdk to rev c02a28868825edfa57ab77947b8cb15e741c5598

third_party/mojo/src/mojo/edk/system/connection_manager_unittest.cc

 // Copyright 2015 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 is really a unit test for |MasterConnectionManager| and
 // |SlaveConnectionManager| (since they need to be tested together).
 
 #include "mojo/edk/system/connection_manager.h"
 
 #include <stdint.h>
@@ skipping 208 matching lines @@
   // TODO(vtl): If/when I add the ability to get one's own process identifier,
   // there'll be more we can check.
   EXPECT_NE(slave1_id, slave2_id);
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(slave1.AllowConnect(connection_id));
   EXPECT_TRUE(slave2.AllowConnect(connection_id));
 
   ProcessIdentifier peer1 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h1;
-  EXPECT_TRUE(slave1.Connect(connection_id, &peer1, &h1));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave1.Connect(connection_id, &peer1, &h1));
   EXPECT_EQ(slave2_id, peer1);
   EXPECT_TRUE(h1.is_valid());
   ProcessIdentifier peer2 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_TRUE(slave2.Connect(connection_id, &peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave2.Connect(connection_id, &peer2, &h2));
   EXPECT_EQ(slave1_id, peer2);
   EXPECT_TRUE(h2.is_valid());
 
   EXPECT_TRUE(ArePlatformHandlesConnected(h1.get(), h2.get()));
 
   // The process manager shouldn't have gotten any notifications yet. (Spin the
   // message loop to make sure none were enqueued.)
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(0u, master_process_delegate().on_slave_disconnect_calls());
 
@@ skipping 67 matching lines @@
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave2_id));
   EXPECT_NE(slave1_id, slave2_id);
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(slave1.AllowConnect(connection_id));
   EXPECT_TRUE(slave2.AllowConnect(connection_id));
 
   EXPECT_TRUE(slave1.CancelConnect(connection_id));
   ProcessIdentifier peer2 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_FALSE(slave2.Connect(connection_id, &peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::FAILURE,
+            slave2.Connect(connection_id, &peer2, &h2));
   EXPECT_EQ(kInvalidProcessIdentifier, peer2);
   EXPECT_FALSE(h2.is_valid());
 
   slave1.Shutdown();
   slave2.Shutdown();
   master.Shutdown();
 }
 
 // Tests that pending connections are removed on error.
 TEST_F(ConnectionManagerTest, ErrorRemovePending) {
@@ skipping 21 matching lines @@
   slave1.Shutdown();
 
   // |OnSlaveDisconnect()| should be called. After it's called, this means that
   // the disconnect has been detected and handled, including the removal of the
   // pending connection.
   master_process_delegate().RunUntilNotified();
   EXPECT_EQ(1u, master_process_delegate().on_slave_disconnect_calls());
 
   ProcessIdentifier peer2 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_FALSE(slave2.Connect(connection_id, &peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::FAILURE,
+            slave2.Connect(connection_id, &peer2, &h2));
   EXPECT_EQ(kInvalidProcessIdentifier, peer2);
   EXPECT_FALSE(h2.is_valid());
 
   slave2.Shutdown();
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, ConnectSlaveToSelf) {
   MasterConnectionManager master(platform_support());
   master.Init(base::MessageLoop::current()->task_runner(),
               &master_process_delegate());
 
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
   ProcessIdentifier slave_id =
       ConnectSlave(&master, &slave_process_delegate, &slave, "slave");
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave_id));
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(slave.AllowConnect(connection_id));
   EXPECT_TRUE(slave.AllowConnect(connection_id));
 
-  // Currently, the connect-to-self case is signalled by the master not sending
-  // back a handle.
   ProcessIdentifier peer1 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h1;
-  EXPECT_TRUE(slave.Connect(connection_id, &peer1, &h1));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_SAME_PROCESS,
+            slave.Connect(connection_id, &peer1, &h1));
   EXPECT_EQ(slave_id, peer1);
   EXPECT_FALSE(h1.is_valid());
   ProcessIdentifier peer2 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_TRUE(slave.Connect(connection_id, &peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_SAME_PROCESS,
+            slave.Connect(connection_id, &peer2, &h2));
   EXPECT_EQ(slave_id, peer2);
   EXPECT_FALSE(h2.is_valid());
 
   slave.Shutdown();
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, ConnectSlavesTwice) {
   MasterConnectionManager master(platform_support());
   master.Init(base::MessageLoop::current()->task_runner(),
@@ skipping 11 matching lines @@
       ConnectSlave(&master, &slave2_process_delegate, &slave2, "slave2");
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave2_id));
   EXPECT_NE(slave1_id, slave2_id);
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(slave1.AllowConnect(connection_id));
   EXPECT_TRUE(slave2.AllowConnect(connection_id));
 
   ProcessIdentifier peer1 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h1;
-  EXPECT_TRUE(slave1.Connect(connection_id, &peer1, &h1));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave1.Connect(connection_id, &peer1, &h1));
   EXPECT_EQ(slave2_id, peer1);
   ProcessIdentifier peer2 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_TRUE(slave2.Connect(connection_id, &peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave2.Connect(connection_id, &peer2, &h2));
   EXPECT_EQ(slave1_id, peer2);
 
   EXPECT_TRUE(ArePlatformHandlesConnected(h1.get(), h2.get()));
 
-  // Currently, the master doesn't detect the case of connecting a pair of
-  // slaves that are already connected. (Doing so would require more careful
-  // tracking and is prone to races -- especially if we want slaves to be able
-  // to tear down no-longer-needed connections.) But the slaves should be able
-  // to do the tracking themselves (using the peer process identifiers).
+  // TODO(vtl): Currently, the master doesn't detect the case of connecting a
+  // pair of slaves that are already connected. (Doing so would require more
+  // careful tracking and is prone to races -- especially if we want slaves to
+  // be able to tear down no-longer-needed connections.) But the slaves should
+  // be able to do the tracking themselves (using the peer process identifiers).
   connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(slave1.AllowConnect(connection_id));
   EXPECT_TRUE(slave2.AllowConnect(connection_id));
 
   h1.reset();
   h2.reset();
+  // TODO(vtl): FIXME -- this will break when I implemented
+  // SUCCESS_CONNECT_REUSE_CONNECTION.
   ProcessIdentifier second_peer2 = kInvalidProcessIdentifier;
-  EXPECT_TRUE(slave2.Connect(connection_id, &second_peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave2.Connect(connection_id, &second_peer2, &h2));
   ProcessIdentifier second_peer1 = kInvalidProcessIdentifier;
-  EXPECT_TRUE(slave1.Connect(connection_id, &second_peer1, &h1));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave1.Connect(connection_id, &second_peer1, &h1));
 
   EXPECT_EQ(peer1, second_peer1);
   EXPECT_EQ(peer2, second_peer2);
   EXPECT_TRUE(ArePlatformHandlesConnected(h1.get(), h2.get()));
 
   slave2.Shutdown();
   slave1.Shutdown();
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, ConnectMasterToSlave) {
   MasterConnectionManager master(platform_support());
   master.Init(base::MessageLoop::current()->task_runner(),
               &master_process_delegate());
 
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
   ProcessIdentifier slave_id =
       ConnectSlave(&master, &slave_process_delegate, &slave, "slave");
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave_id));
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(master.AllowConnect(connection_id));
   EXPECT_TRUE(slave.AllowConnect(connection_id));
 
   ProcessIdentifier master_peer = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle master_h;
-  EXPECT_TRUE(master.Connect(connection_id, &master_peer, &master_h));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            master.Connect(connection_id, &master_peer, &master_h));
   EXPECT_EQ(slave_id, master_peer);
   EXPECT_TRUE(master_h.is_valid());
   ProcessIdentifier slave_peer = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle slave_h;
-  EXPECT_TRUE(slave.Connect(connection_id, &slave_peer, &slave_h));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave.Connect(connection_id, &slave_peer, &slave_h));
   EXPECT_EQ(kMasterProcessIdentifier, slave_peer);
   EXPECT_TRUE(slave_h.is_valid());
 
   EXPECT_TRUE(ArePlatformHandlesConnected(master_h.get(), slave_h.get()));
 
   slave.Shutdown();
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, ConnectMasterToSelf) {
   MasterConnectionManager master(platform_support());
   master.Init(base::MessageLoop::current()->task_runner(),
               &master_process_delegate());
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(master.AllowConnect(connection_id));
   EXPECT_TRUE(master.AllowConnect(connection_id));
 
-  // Currently, the connect-to-self case is signalled by the master not sending
-  // back a handle.
   ProcessIdentifier peer1 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h1;
-  EXPECT_TRUE(master.Connect(connection_id, &peer1, &h1));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_SAME_PROCESS,
+            master.Connect(connection_id, &peer1, &h1));
   EXPECT_EQ(kMasterProcessIdentifier, peer1);
   EXPECT_FALSE(h1.is_valid());
   ProcessIdentifier peer2 = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_TRUE(master.Connect(connection_id, &peer2, &h2));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_SAME_PROCESS,
+            master.Connect(connection_id, &peer2, &h2));
   EXPECT_EQ(kMasterProcessIdentifier, peer2);
   EXPECT_FALSE(h2.is_valid());
 
   EXPECT_EQ(peer1, peer2);
 
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, MasterCancelConnect) {
   MasterConnectionManager master(platform_support());
   master.Init(base::MessageLoop::current()->task_runner(),
               &master_process_delegate());
 
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
   ProcessIdentifier slave_id =
       ConnectSlave(&master, &slave_process_delegate, &slave, "slave");
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave_id));
 
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   EXPECT_TRUE(master.AllowConnect(connection_id));
   EXPECT_TRUE(slave.AllowConnect(connection_id));
 
   EXPECT_TRUE(master.CancelConnect(connection_id));
   ProcessIdentifier peer = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h;
-  EXPECT_FALSE(slave.Connect(connection_id, &peer, &h));
+  EXPECT_EQ(ConnectionManager::Result::FAILURE,
+            slave.Connect(connection_id, &peer, &h));
   EXPECT_EQ(kInvalidProcessIdentifier, peer);
   EXPECT_FALSE(h.is_valid());
 
   slave.Shutdown();
   master.Shutdown();
 }
 
 TEST_F(ConnectionManagerTest, AddSlaveThenImmediateShutdown) {
   MasterConnectionManager master(platform_support());
   master.Init(base::MessageLoop::current()->task_runner(),
@@ skipping 16 matching lines @@
 
   embedder::PlatformChannelPair platform_channel_pair;
   ConnectionIdentifier connection_id = master.GenerateConnectionIdentifier();
   ProcessIdentifier slave_id = master.AddSlaveAndBootstrap(
       new TestSlaveInfo("slave"), platform_channel_pair.PassServerHandle(),
       connection_id);
   EXPECT_TRUE(IsValidSlaveProcessIdentifier(slave_id));
 
   embedder::ScopedPlatformHandle h1;
   ProcessIdentifier master_peer = kInvalidProcessIdentifier;
-  EXPECT_TRUE(master.Connect(connection_id, &master_peer, &h1));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            master.Connect(connection_id, &master_peer, &h1));
   EXPECT_EQ(slave_id, master_peer);
   EXPECT_TRUE(h1.is_valid());
 
   // We can delay creating/initializing |slave| for quite a while.
   MockSlaveProcessDelegate slave_process_delegate;
   SlaveConnectionManager slave(platform_support());
   slave.Init(base::MessageLoop::current()->task_runner(),
              &slave_process_delegate, platform_channel_pair.PassClientHandle());
 
   ProcessIdentifier slave_peer = kInvalidProcessIdentifier;
   embedder::ScopedPlatformHandle h2;
-  EXPECT_TRUE(slave.Connect(connection_id, &slave_peer, &h2));
+  EXPECT_EQ(ConnectionManager::Result::SUCCESS_CONNECT_NEW_CONNECTION,
+            slave.Connect(connection_id, &slave_peer, &h2));
   EXPECT_EQ(kMasterProcessIdentifier, slave_peer);
 
   EXPECT_TRUE(ArePlatformHandlesConnected(h1.get(), h2.get()));
 
   slave.Shutdown();
   master.Shutdown();
 }
 
 // TODO(vtl): More shutdown cases for |AddSlaveAndBootstrap()|?
 
 }  // namespace
 }  // namespace system
 }  // namespace mojo