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 IPC {
+
 namespace {
 
 // 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),
@@ skipping 80 matching lines @@
   }
   Channel::Mode mode() { return mode_; }
   WaitableEvent* done_event() { return done_.get(); }
   WaitableEvent* shutdown_event() { return &shutdown_event_; }
   void ResetChannel() { channel_.reset(); }
   // Derived classes need to call this when they've completed their part of
   // the test.
   void Done() { done_->Signal(); }
 
  protected:
-  IPC::SyncChannel* channel() { return channel_.get(); }
+  SyncChannel* channel() { return channel_.get(); }
   // Functions for dervied classes to implement if they wish.
   virtual void Run() { }
   virtual void OnAnswer(int* answer) { NOTREACHED(); }
   virtual void OnAnswerDelay(Message* reply_msg) {
     // The message handler map below can only take one entry for
     // SyncChannelTestMsg_AnswerToLife, so since some classes want
     // the normal version while other want the delayed reply, we
     // call the normal version if the derived class didn't override
     // this function.
     int answer;
@@ skipping 312 matching lines @@
 // 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 {
@@ skipping 583 matching lines @@
   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 93 matching lines @@
 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 116 matching lines @@
       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