There are times on the Mac when pipe names of 0 length may occur. Let the caller handle

ipc/ipc_channel_posix_unittest.cc

 // Copyright (c) 2011 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.
 
 // These tests are POSIX only.
 
 #include "ipc/ipc_channel_posix.h"
 
 #include <fcntl.h>
 #include <sys/socket.h>
@@ skipping 263 matching lines @@
   channel.Send(message);
   SpinRunLoop(TestTimeouts::action_timeout_ms());
   EXPECT_TRUE(base::KillProcess(handle, 0, false));
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
   EXPECT_EQ(0, exit_code);
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 }
 
+TEST_F(IPCChannelPosixTest, BadChannelName) {
+  // Test empty name
+  IPC::ChannelHandle handle("");
+  IPC::Channel channel(handle, IPC::Channel::MODE_NAMED_SERVER, NULL);
+  ASSERT_FALSE(channel.Connect());
+
+  // Test name that is too long.
+  IPC::ChannelHandle handle2("This_is_a_very_long_name_that_must_be_more_than"

[Mark Mentovai, 2011/08/25 13:11:02]

Do “const char kTooLongName[] =
This_is_a_very_long_name_that_must_be_more_than"…” and then
EXPECT_GE(strlen(kTooLongName), IPC::kMaxPipeNameLength).

Since we expect the buffer size on Linux to be 108 but cap it at 104 anyway (see
ipc_channel_posix.h), you may also want to EXPECT_LT(strlen(kTooLongName), 108)
to ensure that we’re testing the right thing on Linux to. If you don’t like
hardcoding 108, you can do:

  if (sizeof(((sockaddr_un*)0)->sun_path) > IPC::kMaxPipeNameLength)
    EXPECT_LT(strlen(kTooLongName), sizeof(((sockaddr_un*)0)->sun_path));

+                             "104_characters_in_length____Proactively_implement"
+                             "client-centered_synergy_through_top-line"
+                             "platforms_Phosfluorescently_disintermediate_"
+                             "clicks-and-mortar_best_practices_without_"
+                             "future-proof_growth_strategies_Continually"
+                             "pontificate_proactive_potentialities_before"
+                             "leading-edge_processes");

[jeremy, 2011/08/25 07:16:51]

_with_a_cherry_on_top :o)

+  IPC::Channel channel2(handle2, IPC::Channel::MODE_NAMED_SERVER, NULL);
+  ASSERT_FALSE(channel2.Connect());

[Mark Mentovai, 2011/08/25 13:11:02]

Note that the suggested size checks could be ASSERT instead of EXPECT, but I
think that the Connect() checks should be EXPECT instead of ASSERT.

+}
+
 TEST_F(IPCChannelPosixTest, MultiConnection) {
   // Test setting up a connection to an external process, and then have
   // another external process attempt to connect to us.
   IPCChannelPosixTestListener listener(false);
   IPC::ChannelHandle chan_handle(kConnectionSocketTestName);
   SetUpSocket(&chan_handle, IPC::Channel::MODE_NAMED_SERVER);
   IPC::Channel channel(chan_handle, IPC::Channel::MODE_NAMED_SERVER, &listener);
   ASSERT_TRUE(channel.Connect());
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
@@ skipping 86 matching lines @@
   bool connected = channel.Connect();
   if (connected) {
     IPCChannelPosixTest::SpinRunLoop(TestTimeouts::action_max_timeout_ms());
     EXPECT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   } else {
     EXPECT_EQ(IPCChannelPosixTestListener::DISCONNECTED, listener.status());
   }
   return 0;
 }