Reduce number of unnamed-type-template-args violations.

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>
 #include <sys/un.h>
 #include <unistd.h>
 
 #include "base/basictypes.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/test_timeouts.h"
 #include "testing/multiprocess_func_list.h"
 
 namespace {
 
-enum {
-  QUIT_MESSAGE = 47
-};
+static const uint32 kQuitMessage = 47;
 
 class IPCChannelPosixTestListener : public IPC::Channel::Listener {
  public:
   enum STATUS {
     DISCONNECTED,
     MESSAGE_RECEIVED,
     CHANNEL_ERROR,
     CONNECTED,
     DENIED,
     LISTEN_ERROR
   };
 
   IPCChannelPosixTestListener(bool quit_only_on_message)
       : status_(DISCONNECTED), quit_only_on_message_(quit_only_on_message) {}
 
   virtual ~IPCChannelPosixTestListener() {}
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
-    EXPECT_EQ(message.type(), QUIT_MESSAGE);
+    EXPECT_EQ(message.type(), kQuitMessage);
     status_ = MESSAGE_RECEIVED;
     QuitRunLoop();
     return true;
   }
 
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
     status_ = CONNECTED;
     if (!quit_only_on_message_) {
       QuitRunLoop();
     }
@@ skipping 23 matching lines @@
   STATUS status() { return status_; }
 
   void QuitRunLoop() {
     MessageLoopForIO::current()->QuitNow();
   }
 
  private:
   // The current status of the listener.
   STATUS status_;
   // If |quit_only_on_message_| then the listener will only break out of
-  // the run loop when the QUIT_MESSAGE is received.
+  // the run loop when kQuitMessage is received.
   bool quit_only_on_message_;
 };
 
 }  // namespace
 
 class IPCChannelPosixTest : public base::MultiProcessTest {
  public:
   static const char kConnectionSocketTestName[];
   static void SetUpSocket(IPC::ChannelHandle *handle,
                           IPC::Channel::Mode mode);
@@ skipping 35 matching lines @@
   server_address.sun_family = AF_UNIX;
   int path_len = snprintf(server_address.sun_path, IPC::kMaxPipeNameLength,
                           "%s", name.c_str());
   DCHECK_EQ(static_cast<int>(name.length()), path_len);
   size_t server_address_len = offsetof(struct sockaddr_un,
                                        sun_path) + path_len + 1;
 
   if (mode == IPC::Channel::MODE_NAMED_SERVER) {
     // Only one server at a time. Cleanup garbage if it exists.
     unlink(name.c_str());
-      // Make sure the path we need exists.
+    // Make sure the path we need exists.
     FilePath path(name);
     FilePath dir_path = path.DirName();
     ASSERT_TRUE(file_util::CreateDirectory(dir_path));
     ASSERT_GE(bind(socket_fd,
                    reinterpret_cast<struct sockaddr *>(&server_address),
                    server_address_len), 0) << server_address.sun_path
                                            << ": " << strerror(errno)
                                            << "(" << errno << ")";
     ASSERT_GE(listen(socket_fd, SOMAXCONN), 0) << server_address.sun_path
                                                << ": " << strerror(errno)
@@ skipping 64 matching lines @@
   ASSERT_TRUE(channel.Connect());
   ASSERT_TRUE(channel.AcceptsConnections());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
   base::ProcessHandle handle = SpawnChild("IPCChannelPosixTestConnectionProc",
                                           false);
   ASSERT_TRUE(handle);
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
-  IPC::Message* message = new IPC::Message(0, // routing_id
-                                           QUIT_MESSAGE, // message type
+  IPC::Message* message = new IPC::Message(0,  // routing_id
+                                           kQuitMessage,  // message type
                                            IPC::Message::PRIORITY_NORMAL);
   channel.Send(message);
   SpinRunLoop(TestTimeouts::action_timeout_ms());
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
   EXPECT_EQ(0, exit_code);
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 }
 
@@ skipping 17 matching lines @@
   ASSERT_TRUE(channel.HasAcceptedConnection());
   channel.ResetToAcceptingConnectionState();
   ASSERT_FALSE(channel.HasAcceptedConnection());
 
   base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixTestConnectionProc",
                                           false);
   ASSERT_TRUE(handle2);
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   ASSERT_EQ(IPCChannelPosixTestListener::CONNECTED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
-  IPC::Message* message = new IPC::Message(0, // routing_id
-                                           QUIT_MESSAGE, // message type
+  IPC::Message* message = new IPC::Message(0,  // routing_id
+                                           kQuitMessage,  // message type
                                            IPC::Message::PRIORITY_NORMAL);
   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());
 }
@@ skipping 17 matching lines @@
   ASSERT_TRUE(channel.HasAcceptedConnection());
   base::ProcessHandle handle2 = SpawnChild("IPCChannelPosixFailConnectionProc",
                                            false);
   ASSERT_TRUE(handle2);
   SpinRunLoop(TestTimeouts::action_max_timeout_ms());
   int exit_code = 0;
   EXPECT_TRUE(base::WaitForExitCode(handle2, &exit_code));
   EXPECT_EQ(exit_code, 0);
   ASSERT_EQ(IPCChannelPosixTestListener::DENIED, listener.status());
   ASSERT_TRUE(channel.HasAcceptedConnection());
-  IPC::Message* message = new IPC::Message(0, // routing_id
-                                           QUIT_MESSAGE, // message type
+  IPC::Message* message = new IPC::Message(0,  // routing_id
+                                           kQuitMessage,  // message type
                                            IPC::Message::PRIORITY_NORMAL);
   channel.Send(message);
   SpinRunLoop(TestTimeouts::action_timeout_ms());
   EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code));
   EXPECT_EQ(exit_code, 0);
   ASSERT_EQ(IPCChannelPosixTestListener::CHANNEL_ERROR, listener.status());
   ASSERT_FALSE(channel.HasAcceptedConnection());
 }
 
 TEST_F(IPCChannelPosixTest, DoubleServer) {
@@ skipping 58 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;
 }