Move IPC tests into anonymous namespaces.

ipc/ipc_sync_channel_unittest.cc

 // Copyright (c) 2012 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.
 //
 // Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
@@ skipping 11 matching lines @@
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sender.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ipc/ipc_sync_message_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::WaitableEvent;
 
 namespace IPC {
-
 namespace {
 
 // Base class for a "process" with listener and IPC threads.
 class Worker : public Listener, public Sender {
  public:
   // Will create a channel without a name.
   Worker(Channel::Mode mode, const std::string& thread_name)
       : done_(new WaitableEvent(false, false)),
         channel_created_(new WaitableEvent(false, false)),
         mode_(mode),
@@ skipping 216 matching lines @@
   // wait for all the workers to finish
   for (size_t i = 0; i < workers.size(); ++i)
     workers[i]->done_event()->Wait();
 
   for (size_t i = 0; i < workers.size(); ++i) {
     workers[i]->Shutdown();
     delete workers[i];
   }
 }
 
-}  // namespace
-
 class IPCSyncChannelTest : public testing::Test {
  private:
   MessageLoop message_loop_;
 };
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class SimpleServer : public Worker {
  public:
   explicit SimpleServer(bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         pump_during_send_(pump_during_send) { }
   void Run() {
     SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
     Done();
   }
@@ skipping 11 matching lines @@
   }
 };
 
 void Simple(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new SimpleServer(pump_during_send));
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests basic synchronous call
 TEST_F(IPCSyncChannelTest, Simple) {
   Simple(false);
   Simple(true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 // Worker classes which override how the sync channel is created to use the
 // two-step initialization (calling the lightweight constructor and then
 // ChannelProxy::Init separately) process.
 class TwoStepServer : public Worker {
  public:
   explicit TwoStepServer(bool create_pipe_now)
       : Worker(Channel::MODE_SERVER, "simpler_server"),
         create_pipe_now_(create_pipe_now) { }
 
@@ skipping 33 matching lines @@
   bool create_pipe_now_;
 };
 
 void TwoStep(bool create_server_pipe_now, bool create_client_pipe_now) {
   std::vector<Worker*> workers;
   workers.push_back(new TwoStepServer(create_server_pipe_now));
   workers.push_back(new TwoStepClient(create_client_pipe_now));
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests basic two-step initialization, where you call the lightweight
 // constructor then Init.
 TEST_F(IPCSyncChannelTest, TwoStepInitialization) {
   TwoStep(false, false);
   TwoStep(false, true);
   TwoStep(true, false);
   TwoStep(true, true);
 }
 
-
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class DelayClient : public Worker {
  public:
   DelayClient() : Worker(Channel::MODE_CLIENT, "delay_client") { }
 
   void OnAnswerDelay(Message* reply_msg) {
     SyncChannelTestMsg_AnswerToLife::WriteReplyParams(reply_msg, 42);
     Send(reply_msg);
     Done();
   }
 };
 
 void DelayReply(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new SimpleServer(pump_during_send));
   workers.push_back(new DelayClient());
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that asynchronous replies work
 TEST_F(IPCSyncChannelTest, DelayReply) {
   DelayReply(false);
   DelayReply(true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class NoHangServer : public Worker {
  public:
   NoHangServer(WaitableEvent* got_first_reply, bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "no_hang_server"),
         got_first_reply_(got_first_reply),
         pump_during_send_(pump_during_send) { }
   void Run() {
     SendAnswerToLife(pump_during_send_, base::kNoTimeout, true);
     got_first_reply_->Signal();
@@ skipping 26 matching lines @@
 };
 
 void NoHang(bool pump_during_send) {
   WaitableEvent got_first_reply(false, false);
   std::vector<Worker*> workers;
   workers.push_back(new NoHangServer(&got_first_reply, pump_during_send));
   workers.push_back(new NoHangClient(&got_first_reply));
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that caller doesn't hang if receiver dies
 TEST_F(IPCSyncChannelTest, NoHang) {
   NoHang(false);
   NoHang(true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class UnblockServer : public Worker {
  public:
   UnblockServer(bool pump_during_send, bool delete_during_send)
     : Worker(Channel::MODE_SERVER, "unblock_server"),
       pump_during_send_(pump_during_send),
       delete_during_send_(delete_during_send) { }
   void Run() {
     if (delete_during_send_) {
       // Use custom code since race conditions mean the answer may or may not be
@@ skipping 35 matching lines @@
   bool pump_during_send_;
 };
 
 void Unblock(bool server_pump, bool client_pump, bool delete_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new UnblockServer(server_pump, delete_during_send));
   workers.push_back(new UnblockClient(client_pump));
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that the caller unblocks to answer a sync message from the receiver.
 TEST_F(IPCSyncChannelTest, Unblock) {
   Unblock(false, false, false);
   Unblock(false, true, false);
   Unblock(true, false, false);
   Unblock(true, true, false);
 }
 
-//-----------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 // Tests that the the SyncChannel object can be deleted during a Send.
 TEST_F(IPCSyncChannelTest, ChannelDeleteDuringSend) {
   Unblock(false, false, true);
   Unblock(false, true, true);
   Unblock(true, false, true);
   Unblock(true, true, true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class RecursiveServer : public Worker {
  public:
   RecursiveServer(bool expected_send_result, bool pump_first, bool pump_second)
       : Worker(Channel::MODE_SERVER, "recursive_server"),
         expected_send_result_(expected_send_result),
         pump_first_(pump_first), pump_second_(pump_second) {}
   void Run() {
     SendDouble(pump_first_, expected_send_result_);
     Done();
@@ skipping 39 matching lines @@
 
 void Recursive(
     bool server_pump_first, bool server_pump_second, bool client_pump) {
   std::vector<Worker*> workers;
   workers.push_back(
       new RecursiveServer(true, server_pump_first, server_pump_second));
   workers.push_back(new RecursiveClient(client_pump, false));
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests a server calling Send while another Send is pending.
 TEST_F(IPCSyncChannelTest, Recursive) {
   Recursive(false, false, false);
   Recursive(false, false, true);
   Recursive(false, true, false);
   Recursive(false, true, true);
   Recursive(true, false, false);
   Recursive(true, false, true);
   Recursive(true, true, false);
   Recursive(true, true, true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 void RecursiveNoHang(
     bool server_pump_first, bool server_pump_second, bool client_pump) {
   std::vector<Worker*> workers;
   workers.push_back(
       new RecursiveServer(false, server_pump_first, server_pump_second));
   workers.push_back(new RecursiveClient(client_pump, true));
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that if a caller makes a sync call during an existing sync call and
 // the receiver dies, neither of the Send() calls hang.
 TEST_F(IPCSyncChannelTest, RecursiveNoHang) {
   RecursiveNoHang(false, false, false);
   RecursiveNoHang(false, false, true);
   RecursiveNoHang(false, true, false);
   RecursiveNoHang(false, true, true);
   RecursiveNoHang(true, false, false);
   RecursiveNoHang(true, false, true);
   RecursiveNoHang(true, true, false);
   RecursiveNoHang(true, true, true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class MultipleServer1 : public Worker {
  public:
   explicit MultipleServer1(bool pump_during_send)
     : Worker("test_channel1", Channel::MODE_SERVER),
       pump_during_send_(pump_during_send) { }
 
   void Run() {
     SendDouble(pump_during_send_, true);
     Done();
@@ skipping 80 matching lines @@
   worker->OverrideThread(&worker_thread);
   workers.push_back(worker);
 
   worker = new MultipleClient1(
       &client1_msg_received, &client1_can_reply);
   workers.push_back(worker);
 
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that multiple SyncObjects on the same listener thread can unblock each
 // other.
 TEST_F(IPCSyncChannelTest, Multiple) {
   Multiple(false, false);
   Multiple(false, true);
   Multiple(true, false);
   Multiple(true, true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 // This class provides server side functionality to test the case where
 // multiple sync channels are in use on the same thread on the client and
 // nested calls are issued.
 class QueuedReplyServer : public Worker {
  public:
   QueuedReplyServer(base::Thread* listener_thread,
                     const std::string& channel_name,
                     const std::string& reply_text)
       : Worker(channel_name, Channel::MODE_SERVER),
@@ skipping 78 matching lines @@
 
   worker = new QueuedReplyClient(&client_worker_thread,
                                  "QueuedReply_Server2",
                                  "Got second message",
                                  client_pump);
   workers.push_back(worker);
 
   RunTest(workers);
 }
 
-}  // namespace
-
 // While a blocking send is in progress, the listener thread might answer other
 // synchronous messages.  This tests that if during the response to another
 // message the reply to the original messages comes, it is queued up correctly
 // and the original Send is unblocked later.
 // We also test that the send call stacks unwind correctly when the channel
 // pumps messages while waiting for a response.
 TEST_F(IPCSyncChannelTest, QueuedReply) {
   QueuedReply(false);
   QueuedReply(true);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class ChattyClient : public Worker {
  public:
   ChattyClient() :
       Worker(Channel::MODE_CLIENT, "chatty_client") { }
 
   void OnAnswer(int* answer) {
     // The PostMessage limit is 10k.  Send 20% more than that.
     const int kMessageLimit = 10000;
     const int kMessagesToSend = kMessageLimit * 120 / 100;
     for (int i = 0; i < kMessagesToSend; ++i) {
       if (!SendDouble(false, true))
         break;
     }
     *answer = 42;
     Done();
   }
 };
 
 void ChattyServer(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new UnblockServer(pump_during_send, false));
   workers.push_back(new ChattyClient());
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests http://b/1093251 - that sending lots of sync messages while
 // the receiver is waiting for a sync reply does not overflow the PostMessage
 // queue.
 TEST_F(IPCSyncChannelTest, ChattyServer) {
   ChattyServer(false);
   ChattyServer(true);
 }
 
 //------------------------------------------------------------------------------
 
-namespace {
-
 class TimeoutServer : public Worker {
  public:
   TimeoutServer(int timeout_ms,
                 std::vector<bool> timeout_seq,
                 bool pump_during_send)
       : Worker(Channel::MODE_SERVER, "timeout_server"),
         timeout_ms_(timeout_ms),
         timeout_seq_(timeout_seq),
         pump_during_send_(pump_during_send) {
   }
@@ skipping 66 matching lines @@
   timeout_seq.push_back(true);
   timeout_seq.push_back(false);
   timeout_seq.push_back(false);
   timeout_seq.push_back(true);
   timeout_seq.push_back(false);
   workers.push_back(new TimeoutServer(100, timeout_seq, pump_during_send));
   workers.push_back(new UnresponsiveClient(timeout_seq));
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that SendWithTimeout does not time-out if the response comes back fast
 // enough.
 TEST_F(IPCSyncChannelTest, SendWithTimeoutOK) {
   SendWithTimeoutOK(false);
   SendWithTimeoutOK(true);
 }
 
 // Tests that SendWithTimeout does time-out.
 TEST_F(IPCSyncChannelTest, SendWithTimeoutTimeout) {
   SendWithTimeoutTimeout(false);
   SendWithTimeoutTimeout(true);
 }
 
 // Sends some message that time-out and some that succeed.
 // Crashes flakily, http://crbug.com/70075.
 TEST_F(IPCSyncChannelTest, DISABLED_SendWithTimeoutMixedOKAndTimeout) {
   SendWithTimeoutMixedOKAndTimeout(false);
   SendWithTimeoutMixedOKAndTimeout(true);
 }
 
 //------------------------------------------------------------------------------
 
-namespace {
-
 void NestedCallback(Worker* server) {
   // Sleep a bit so that we wake up after the reply has been received.
   base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(250));
   server->SendAnswerToLife(true, base::kNoTimeout, true);
 }
 
 bool timeout_occurred = false;
 
 void TimeoutCallback() {
   timeout_occurred = true;
@@ skipping 14 matching lines @@
     // Even though we have a timeout on the Send, it will succeed since for this
     // bug, the reply message comes back and is deserialized, however the done
     // event wasn't set.  So we indirectly use the timeout task to notice if a
     // timeout occurred.
     SendAnswerToLife(true, 10000, true);
     DCHECK(!timeout_occurred);
     Done();
   }
 };
 
-}  // namespace
-
 // Tests http://b/1474092 - that if after the done_event is set but before
 // OnObjectSignaled is called another message is sent out, then after its
 // reply comes back OnObjectSignaled will be called for the first message.
 TEST_F(IPCSyncChannelTest, DoneEventRace) {
   std::vector<Worker*> workers;
   workers.push_back(new DoneEventRaceServer());
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class TestSyncMessageFilter : public SyncMessageFilter {
  public:
   TestSyncMessageFilter(base::WaitableEvent* shutdown_event,
                         Worker* worker,
                         scoped_refptr<base::MessageLoopProxy> message_loop)
       : SyncMessageFilter(shutdown_event),
         worker_(worker),
         message_loop_(message_loop) {
   }
@@ skipping 69 matching lines @@
 
   bool Send(Message* msg) {
     send_result_ = Worker::Send(msg);
     Done();
     return send_result_;
   }
 
   bool send_result_;
 };
 
-}  // namespace
-
 // Tests basic synchronous call
 TEST_F(IPCSyncChannelTest, SyncMessageFilter) {
   std::vector<Worker*> workers;
   workers.push_back(new SyncMessageFilterServer());
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
 
 // Test the case when the channel is closed and a Send is attempted after that.
 TEST_F(IPCSyncChannelTest, SendAfterClose) {
   ServerSendAfterClose server;
   server.Start();
 
   server.done_event()->Wait();
   server.done_event()->Reset();
 
   server.SendDummy();
   server.done_event()->Wait();
 
   EXPECT_FALSE(server.send_result());
 
   server.Shutdown();
 }
 
-//-----------------------------------------------------------------------------
-
-namespace {
+//------------------------------------------------------------------------------
 
 class RestrictedDispatchServer : public Worker {
  public:
   RestrictedDispatchServer(WaitableEvent* sent_ping_event,
                            WaitableEvent* wait_event)
       : Worker("restricted_channel", Channel::MODE_SERVER),
         sent_ping_event_(sent_ping_event),
         wait_event_(wait_event) { }
 
   void OnDoPing(int ping) {
@@ skipping 154 matching lines @@
   }
 
   int ping_;
   RestrictedDispatchServer* server_;
   NonRestrictedDispatchServer* server2_;
   int* success_;
   WaitableEvent* sent_ping_event_;
   scoped_ptr<SyncChannel> non_restricted_channel_;
 };
 
-}  // namespace
-
 TEST_F(IPCSyncChannelTest, RestrictedDispatch) {
   WaitableEvent sent_ping_event(false, false);
   WaitableEvent wait_event(false, false);
   RestrictedDispatchServer* server =
       new RestrictedDispatchServer(&sent_ping_event, &wait_event);
   NonRestrictedDispatchServer* server2 =
       new NonRestrictedDispatchServer(&wait_event);
 
   int success = 0;
   std::vector<Worker*> workers;
   workers.push_back(server);
   workers.push_back(server2);
   workers.push_back(new RestrictedDispatchClient(
       &sent_ping_event, server, server2, &success));
   RunTest(workers);
   EXPECT_EQ(4, success);
 }
 
-//-----------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 // This test case inspired by crbug.com/108491
 // We create two servers that use the same ListenerThread but have
 // SetRestrictDispatchToSameChannel set to true.
 // We create clients, then use some specific WaitableEvent wait/signalling to
 // ensure that messages get dispatched in a way that causes a deadlock due to
 // a nested dispatch and an eligible message in a higher-level dispatch's
 // delayed_queue. Specifically, we start with client1 about so send an
 // unblocking message to server1, while the shared listener thread for the
 // servers server1 and server2 is about to send a non-unblocking message to
 // client1. At the same time, client2 will be about to send an unblocking
 // message to server2. Server1 will handle the client1->server1 message by
 // telling server2 to send a non-unblocking message to client2.
 // What should happen is that the send to server2 should find the pending,
 // same-context client2->server2 message to dispatch, causing client2 to
 // unblock then handle the server2->client2 message, so that the shared
 // servers' listener thread can then respond to the client1->server1 message.
 // Then client1 can handle the non-unblocking server1->client1 message.
 // The old code would end up in a state where the server2->client2 message is
 // sent, but the client2->server2 message (which is eligible for dispatch, and
 // which is what client2 is waiting for) is stashed in a local delayed_queue
 // that has server1's channel context, causing a deadlock.
 // WaitableEvents in the events array are used to:
 //   event 0: indicate to client1 that server listener is in OnDoServerTask
 //   event 1: indicate to client1 that client2 listener is in OnDoClient2Task
 //   event 2: indicate to server1 that client2 listener is in OnDoClient2Task
 //   event 3: indicate to client2 that server listener is in OnDoServerTask
 
-namespace {
-
 class RestrictedDispatchDeadlockServer : public Worker {
  public:
   RestrictedDispatchDeadlockServer(int server_num,
                                    WaitableEvent* server_ready_event,
                                    WaitableEvent** events,
                                    RestrictedDispatchDeadlockServer* peer)
       : Worker(server_num == 1 ? "channel1" : "channel2", Channel::MODE_SERVER),
         server_num_(server_num),
         server_ready_event_(server_ready_event),
         events_(events),
@@ skipping 159 matching lines @@
 
   RestrictedDispatchDeadlockServer* server_;
   RestrictedDispatchDeadlockClient2* peer_;
   WaitableEvent* server_ready_event_;
   WaitableEvent** events_;
   bool received_msg_;
   bool received_noarg_reply_;
   bool done_issued_;
 };
 
-}  // namespace
-
 TEST_F(IPCSyncChannelTest, RestrictedDispatchDeadlock) {
   std::vector<Worker*> workers;
 
   // A shared worker thread so that server1 and server2 run on one thread.
   base::Thread worker_thread("RestrictedDispatchDeadlock");
   ASSERT_TRUE(worker_thread.Start());
 
   WaitableEvent server1_ready(false, false);
   WaitableEvent server2_ready(false, false);
 
@@ skipping 22 matching lines @@
   server1->OverrideThread(&worker_thread);
   workers.push_back(server1);
 
   client1 = new RestrictedDispatchDeadlockClient1(server1, client2,
                                                   &server1_ready, events);
   workers.push_back(client1);
 
   RunTest(workers);
 }
 
-//-----------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 // This test case inspired by crbug.com/120530
 // We create 4 workers that pipe to each other W1->W2->W3->W4->W1 then we send a
 // message that recurses through 3, 4 or 5 steps to make sure, say, W1 can
 // re-enter when called from W4 while it's sending a message to W2.
 // The first worker drives the whole test so it must be treated specially.
-namespace {
 
 class RestrictedDispatchPipeWorker : public Worker {
  public:
   RestrictedDispatchPipeWorker(
       const std::string &channel1,
       WaitableEvent* event1,
       const std::string &channel2,
       WaitableEvent* event2,
       int group,
       int* success)
@@ skipping 59 matching lines @@
   }
 
   scoped_ptr<SyncChannel> other_channel_;
   WaitableEvent* event1_;
   WaitableEvent* event2_;
   std::string other_channel_name_;
   int group_;
   int* success_;
 };
 
-}  // namespace
-
 TEST_F(IPCSyncChannelTest, RestrictedDispatch4WayDeadlock) {
   int success = 0;
   std::vector<Worker*> workers;
   WaitableEvent event0(true, false);
   WaitableEvent event1(true, false);
   WaitableEvent event2(true, false);
   WaitableEvent event3(true, false);
   workers.push_back(new RestrictedDispatchPipeWorker(
         "channel0", &event0, "channel1", &event1, 1, &success));
   workers.push_back(new RestrictedDispatchPipeWorker(
         "channel1", &event1, "channel2", &event2, 2, NULL));
   workers.push_back(new RestrictedDispatchPipeWorker(
         "channel2", &event2, "channel3", &event3, 3, NULL));
   workers.push_back(new RestrictedDispatchPipeWorker(
         "channel3", &event3, "channel0", &event0, 4, NULL));
   RunTest(workers);
   EXPECT_EQ(3, success);
 }
 
+//------------------------------------------------------------------------------
 
-//-----------------------------------------------------------------------------
-//
 // This test case inspired by crbug.com/122443
 // We want to make sure a reply message with the unblock flag set correctly
 // behaves as a reply, not a regular message.
 // We have 3 workers. Server1 will send a message to Server2 (which will block),
 // during which it will dispatch a message comming from Client, at which point
 // it will send another message to Server2. While sending that second message it
 // will receive a reply from Server1 with the unblock flag.
 
-namespace {
-
 class ReentrantReplyServer1 : public Worker {
  public:
   ReentrantReplyServer1(WaitableEvent* server_ready)
       : Worker("reentrant_reply1", Channel::MODE_SERVER),
         server_ready_(server_ready) { }
 
   void Run() {
     server2_channel_.reset(new SyncChannel(
         "reentrant_reply2", Channel::MODE_CLIENT, this,
         ipc_thread().message_loop_proxy(), true, shutdown_event()));
@@ skipping 70 matching lines @@
   void Run() {
     server_ready_->Wait();
     Send(new SyncChannelTestMsg_Reentrant2());
     Done();
   }
 
  private:
   WaitableEvent* server_ready_;
 };
 
-}  // namespace
-
 TEST_F(IPCSyncChannelTest, ReentrantReply) {
   std::vector<Worker*> workers;
   WaitableEvent server_ready(false, false);
   workers.push_back(new ReentrantReplyServer2());
   workers.push_back(new ReentrantReplyServer1(&server_ready));
   workers.push_back(new ReentrantReplyClient(&server_ready));
   RunTest(workers);
 }
 
-//-----------------------------------------------------------------------------
+//------------------------------------------------------------------------------
 
 // Generate a validated channel ID using Channel::GenerateVerifiedChannelID().
-namespace {
 
 class VerifiedServer : public Worker {
  public:
   VerifiedServer(base::Thread* listener_thread,
                  const std::string& channel_name,
                  const std::string& reply_text)
       : Worker(channel_name, Channel::MODE_SERVER),
         reply_text_(reply_text) {
     Worker::OverrideThread(listener_thread);
   }
@@ skipping 61 matching lines @@
                               channel_id,
                               "Got first message");
   workers.push_back(worker);
 
   RunTest(workers);
 
 #if defined(OS_WIN)
 #endif
 }
 
-}  // namespace
-
 // Windows needs to send an out-of-band secret to verify the client end of the
 // channel. Test that we still connect correctly in that case.
 TEST_F(IPCSyncChannelTest, Verified) {
   Verified();
 }
 
+}  // namespace
 }  // namespace IPC