Remove using directives ("using namespace x") from mojo/.

Bug: 82078
Change-Id: Iede861b1cf4680d52f3dc1f298ca5f6ec8f398f2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1815574
Auto-Submit: Peter Kasting <pkasting@chromium.org>
Commit-Queue: Oksana Zhuravlova <oksamyt@chromium.org>
Reviewed-by: Oksana Zhuravlova <oksamyt@chromium.org>
Cr-Commit-Position: refs/heads/master@{#698565}

mojo/core/channel_fuzzer.cc

@@ -19,28 +19,26 @@
 #include <windows.h>
 #endif
 
-using namespace mojo::core;
-
 // A fake delegate for each Channel endpoint. By the time an incoming message
 // reaches a Delegate, all interesting message parsing at the lowest protocol
 // layer has already been done by the receiving Channel implementation, so this
 // doesn't need to do any work.
-class FakeChannelDelegate : public Channel::Delegate {
+class FakeChannelDelegate : public mojo::core::Channel::Delegate {
  public:
   FakeChannelDelegate() = default;
   ~FakeChannelDelegate() override = default;
 
   void OnChannelMessage(const void* payload,
                         size_t payload_size,
                         std::vector<mojo::PlatformHandle> handles) override {}
-  void OnChannelError(Channel::Error error) override {}
+  void OnChannelError(mojo::core::Channel::Error error) override {}
 };
 
 // Message deserialization may register handles in the global handle table. We
 // need to initialize Core for that to be OK.
 struct Environment {
   Environment() : main_thread_task_executor(base::MessagePumpType::IO) {
-    InitializeCore();
+    mojo::core::InitializeCore();
   }
 
   base::SingleThreadTaskExecutor main_thread_task_executor;
@@ -54,9 +52,10 @@ extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) {
   mojo::PlatformChannel channel;
 
   FakeChannelDelegate receiver_delegate;
-  auto receiver = Channel::Create(
-      &receiver_delegate, ConnectionParams(channel.TakeLocalEndpoint()),
-      Channel::HandlePolicy::kRejectHandles,
+  auto receiver = mojo::core::Channel::Create(
+      &receiver_delegate,
+      mojo::core::ConnectionParams(channel.TakeLocalEndpoint()),
+      mojo::core::Channel::HandlePolicy::kRejectHandles,
       environment->main_thread_task_executor.task_runner());
 
 #if defined(OS_WIN)
@@ -78,14 +77,15 @@ extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) {
   receiver->Start();
 
   FakeChannelDelegate sender_delegate;
-  auto sender = Channel::Create(
-      &sender_delegate, ConnectionParams(channel.TakeRemoteEndpoint()),
-      Channel::HandlePolicy::kRejectHandles,
+  auto sender = mojo::core::Channel::Create(
+      &sender_delegate,
+      mojo::core::ConnectionParams(channel.TakeRemoteEndpoint()),
+      mojo::core::Channel::HandlePolicy::kRejectHandles,
       environment->main_thread_task_executor.task_runner());
   sender->Start();
 
-  sender->Write(
-      Channel::Message::CreateRawForFuzzing(base::make_span(data, size)));
+  sender->Write(mojo::core::Channel::Message::CreateRawForFuzzing(
+      base::make_span(data, size)));
 
   // Make sure |receiver| does whatever work it's gonna do in response to our
   // message. By the time the loop goes idle, all parsing will be done.

mojo/core/node_channel_fuzzer.cc

@@ -20,59 +20,62 @@
 #include <windows.h>
 #endif
 
-using namespace mojo::core;
+using mojo::core::Channel;
+using mojo::core::ConnectionParams;
+using mojo::core::ports::NodeName;
 
 // Implementation of NodeChannel::Delegate which does nothing. All of the
 // interesting NodeChannel control message message parsing is done by
 // NodeChannel by the time any of the delegate methods are invoked, so there's
 // no need for this to do any work.
-class FakeNodeChannelDelegate : public NodeChannel::Delegate {
+class FakeNodeChannelDelegate : public mojo::core::NodeChannel::Delegate {
  public:
   FakeNodeChannelDelegate() = default;
   ~FakeNodeChannelDelegate() override = default;
 
-  void OnAcceptInvitee(const ports::NodeName& from_node,
-                       const ports::NodeName& inviter_name,
-                       const ports::NodeName& token) override {}
-  void OnAcceptInvitation(const ports::NodeName& from_node,
-                          const ports::NodeName& token,
-                          const ports::NodeName& invitee_name) override {}
-  void OnAddBrokerClient(const ports::NodeName& from_node,
-                         const ports::NodeName& client_name,
+  void OnAcceptInvitee(const NodeName& from_node,
+                       const NodeName& inviter_name,
+                       const NodeName& token) override {}
+  void OnAcceptInvitation(const NodeName& from_node,
+                          const NodeName& token,
+                          const NodeName& invitee_name) override {}
+  void OnAddBrokerClient(const NodeName& from_node,
+                         const NodeName& client_name,
                          base::ProcessHandle process_handle) override {}
-  void OnBrokerClientAdded(const ports::NodeName& from_node,
-                           const ports::NodeName& client_name,
+  void OnBrokerClientAdded(const NodeName& from_node,
+                           const NodeName& client_name,
                            mojo::PlatformHandle broker_channel) override {}
-  void OnAcceptBrokerClient(const ports::NodeName& from_node,
-                            const ports::NodeName& broker_name,
+  void OnAcceptBrokerClient(const NodeName& from_node,
+                            const NodeName& broker_name,
                             mojo::PlatformHandle broker_channel) override {}
-  void OnEventMessage(const ports::NodeName& from_node,
+  void OnEventMessage(const NodeName& from_node,
                       Channel::MessagePtr message) override {}
-  void OnRequestPortMerge(const ports::NodeName& from_node,
-                          const ports::PortName& connector_port_name,
-                          const std::string& token) override {}
-  void OnRequestIntroduction(const ports::NodeName& from_node,
-                             const ports::NodeName& name) override {}
-  void OnIntroduce(const ports::NodeName& from_node,
-                   const ports::NodeName& name,
+  void OnRequestPortMerge(
+      const NodeName& from_node,
+      const mojo::core::ports::PortName& connector_port_name,
+      const std::string& token) override {}
+  void OnRequestIntroduction(const NodeName& from_node,
+                             const NodeName& name) override {}
+  void OnIntroduce(const NodeName& from_node,
+                   const NodeName& name,
                    mojo::PlatformHandle channel_handle) override {}
-  void OnBroadcast(const ports::NodeName& from_node,
+  void OnBroadcast(const NodeName& from_node,
                    Channel::MessagePtr message) override {}
 #if defined(OS_WIN)
-  void OnRelayEventMessage(const ports::NodeName& from_node,
+  void OnRelayEventMessage(const NodeName& from_node,
                            base::ProcessHandle from_process,
-                           const ports::NodeName& destination,
+                           const NodeName& destination,
                            Channel::MessagePtr message) override {}
-  void OnEventMessageFromRelay(const ports::NodeName& from_node,
-                               const ports::NodeName& source_node,
+  void OnEventMessageFromRelay(const NodeName& from_node,
+                               const NodeName& source_node,
                                Channel::MessagePtr message) override {}
 #endif
-  void OnAcceptPeer(const ports::NodeName& from_node,
-                    const ports::NodeName& token,
-                    const ports::NodeName& peer_name,
-                    const ports::PortName& port_name) override {}
-  void OnChannelError(const ports::NodeName& node,
-                      NodeChannel* channel) override {}
+  void OnAcceptPeer(const NodeName& from_node,
+                    const NodeName& token,
+                    const NodeName& peer_name,
+                    const mojo::core::ports::PortName& port_name) override {}
+  void OnChannelError(const NodeName& node,
+                      mojo::core::NodeChannel* channel) override {}
 };
 
 // A fake delegate for the sending Channel endpoint. The sending Channel is not
@@ -93,7 +96,7 @@ class FakeChannelDelegate : public Channel::Delegate {
 // need to initialize Core for that to be OK.
 struct Environment {
   Environment() : main_thread_task_executor(base::MessagePumpType::IO) {
-    InitializeCore();
+    mojo::core::InitializeCore();
   }
 
   base::SingleThreadTaskExecutor main_thread_task_executor;
@@ -107,7 +110,7 @@ extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) {
   mojo::PlatformChannel channel;
 
   FakeNodeChannelDelegate receiver_delegate;
-  auto receiver = NodeChannel::Create(
+  auto receiver = mojo::core::NodeChannel::Create(
       &receiver_delegate, ConnectionParams(channel.TakeLocalEndpoint()),
       Channel::HandlePolicy::kRejectHandles,
       environment->main_thread_task_executor.task_runner(), base::DoNothing());

mojo/core/port_event_fuzzer.cc

@@ -9,19 +9,17 @@
 #include "mojo/core/entrypoints.h"
 #include "mojo/core/node_controller.h"
 
-using namespace mojo::core;
-
 // Message deserialization may register handles in the global handle table. We
 // need to initialize Core for that to be OK.
 struct Environment {
-  Environment() { InitializeCore(); }
+  Environment() { mojo::core::InitializeCore(); }
 };
 
 extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) {
   static base::NoDestructor<Environment> environment;
 
   // Try using the fuzz as the full contents of a port event.
-  NodeController::DeserializeRawBytesAsEventForFuzzer(
+  mojo::core::NodeController::DeserializeRawBytesAsEventForFuzzer(
       base::make_span(data, size));
   return 0;
 }

mojo/core/user_message_fuzzer.cc

@@ -10,30 +10,29 @@
 #include "mojo/core/node_controller.h"
 #include "mojo/core/user_message_impl.h"
 
-using namespace mojo::core;
-
 // Message deserialization may register handles in the global handle table. We
 // need to initialize Core for that to be OK.
 struct Environment {
-  Environment() { InitializeCore(); }
+  Environment() { mojo::core::InitializeCore(); }
 };
 
 extern "C" int LLVMFuzzerTestOneInput(const unsigned char* data, size_t size) {
   static base::NoDestructor<Environment> environment;
 
   // Try using our fuzz input as the payload of an otherwise well-formed user
   // message event.
-  std::unique_ptr<ports::UserMessageEvent> event;
-  MojoResult result = UserMessageImpl::CreateEventForNewSerializedMessage(
-      static_cast<uint32_t>(size), nullptr, 0, &event);
+  std::unique_ptr<mojo::core::ports::UserMessageEvent> event;
+  MojoResult result =
+      mojo::core::UserMessageImpl::CreateEventForNewSerializedMessage(
+          static_cast<uint32_t>(size), nullptr, 0, &event);
   DCHECK_EQ(result, MOJO_RESULT_OK);
   DCHECK(event);
-  auto* message = event->GetMessage<UserMessageImpl>();
+  auto* message = event->GetMessage<mojo::core::UserMessageImpl>();
   std::copy(data, data + size,
             static_cast<unsigned char*>(message->user_payload()));
-  Channel::MessagePtr serialized_event =
-      UserMessageImpl::FinalizeEventMessage(std::move(event));
-  NodeController::DeserializeMessageAsEventForFuzzer(
+  mojo::core::Channel::MessagePtr serialized_event =
+      mojo::core::UserMessageImpl::FinalizeEventMessage(std::move(event));
+  mojo::core::NodeController::DeserializeMessageAsEventForFuzzer(
       std::move(serialized_event));
 
   return 0;