Removing 'using namespace' style violations in src/ipc/

ipc/ipc_sync_channel_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.
 //
 // Unit test for SyncChannel.
 
 #include "ipc/ipc_sync_channel.h"
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/synchronization/waitable_event.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "ipc/ipc_sync_message_unittest.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using namespace IPC;
 using base::WaitableEvent;
 
-namespace {

[brettw, 2011/05/13 19:13:40]

I think we still want to keep the anonymous namespace in this file. There are
general names like "Simple" which will now be exported from this file as
IPC::Simple which we probably don't want. It's perfectly fine to have an
anonymous namespace inside a named one.

[KushalP, 2011/05/13 19:19:17]

Done.

+namespace IPC {
 
 // Base class for a "process" with listener and IPC threads.
 class Worker : public Channel::Listener, public Message::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),
         ipc_thread_((thread_name + "_ipc").c_str()),
@@ skipping 206 matching lines @@
       workers[i]->Start();
   }
 
   // wait for all the workers to finish
   for (size_t i = 0; i < workers.size(); ++i)
     workers[i]->done_event()->Wait();
 
   STLDeleteContainerPointers(workers.begin(), workers.end());
 }
 
-}  // 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 10 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 {
-
 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:
   explicit 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 25 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
       // available.
@@ skipping 34 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 IPC::SyncChannel object can be deleted during a Send.
+// 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:
   explicit 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 79 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),
         reply_text_(reply_text) {
@@ skipping 77 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 {
-
 void DropAssert(const std::string&) {}
 
 class BadServer : public Worker {
  public:
   explicit BadServer(bool pump_during_send)
     : Worker(Channel::MODE_SERVER, "simpler_server"),
       pump_during_send_(pump_during_send) { }
   void Run() {
     int answer = 0;
 
@@ skipping 21 matching lines @@
   bool pump_during_send_;
 };
 
 void BadMessage(bool pump_during_send) {
   std::vector<Worker*> workers;
   workers.push_back(new BadServer(pump_during_send));
   workers.push_back(new SimpleClient());
   RunTest(workers);
 }
 
-}  // namespace
-
 // Tests that if a message is not serialized correctly, the Send() will fail.
 TEST_F(IPCSyncChannelTest, BadMessage) {
   BadMessage(false);
   BadMessage(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 {
-
 class NestedTask : public Task {
  public:
   explicit NestedTask(Worker* server) : server_(server) { }
   void Run() {
     // Sleep a bit so that we wake up after the reply has been received.
     base::PlatformThread::Sleep(250);
     server_->SendAnswerToLife(true, base::kNoTimeout, true);
   }
 
   Worker* server_;
@@ skipping 19 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_occured);
     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 IPC::SyncMessageFilter {
+class TestSyncMessageFilter : public SyncMessageFilter {
  public:
   TestSyncMessageFilter(base::WaitableEvent* shutdown_event, Worker* worker)
       : SyncMessageFilter(shutdown_event),
         worker_(worker),
         thread_("helper_thread") {
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_DEFAULT;
     thread_.StartWithOptions(options);
   }
 
@@ skipping 57 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());
 }
 
 //-----------------------------------------------------------------------------
 
-namespace {
-
 class RestrictedDispatchServer : public Worker {
  public:
   RestrictedDispatchServer(WaitableEvent* sent_ping_event)
       : Worker("restricted_channel", Channel::MODE_SERVER),
         sent_ping_event_(sent_ping_event) { }
 
   void OnDoPing(int ping) {
     // Send an asynchronous message that unblocks the caller.
-    IPC::Message* msg = new SyncChannelTestMsg_Ping(ping);
+    Message* msg = new SyncChannelTestMsg_Ping(ping);
     msg->set_unblock(true);
     Send(msg);
     // Signal the event after the message has been sent on the channel, on the
     // IPC thread.
     ipc_thread().message_loop()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &RestrictedDispatchServer::OnPingSent));
   }
 
   base::Thread* ListenerThread() { return Worker::ListenerThread(); }
 
@@ skipping 100 matching lines @@
   void OnPing(int ping) {
     ping_ = ping;
   }
 
   int ping_;
   RestrictedDispatchServer* server_;
   int* success_;
   WaitableEvent* sent_ping_event_;
 };
 
-}  // namespace
-
 TEST_F(IPCSyncChannelTest, RestrictedDispatch) {
   WaitableEvent sent_ping_event(false, false);
 
   RestrictedDispatchServer* server =
       new RestrictedDispatchServer(&sent_ping_event);
   int success = 0;
   std::vector<Worker*> workers;
   workers.push_back(new NonRestrictedDispatchServer);
   workers.push_back(server);
   workers.push_back(
       new RestrictedDispatchClient(&sent_ping_event, server, &success));
   RunTest(workers);
   EXPECT_EQ(3, success);
 }
+
+}  // namespace IPC