Media Remoting Clean-up: Less-redundant naming, style consistency, etc.

media/remoting/rpc_broker_unittest.cc

 // Copyright 2016 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.
 
-#include "media/remoting/rpc/rpc_broker.h"
+#include "media/remoting/rpc_broker.h"
 
 #include <memory>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "media/remoting/remoting_rpc_message.pb.h"
+#include "media/remoting/rpc.pb.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::Invoke;
 using testing::Return;
 
 namespace media {
 namespace remoting {
 
+namespace {
+
 class FakeMessageSender {
  public:
   FakeMessageSender()
       : received_rpc_(new pb::RpcMessage()),
         has_sent_message_(false),
         send_count_(0),
         weak_factory_(this) {}
   ~FakeMessageSender() {}
 
   void OnSendMessageAndQuit(std::unique_ptr<std::vector<uint8_t>> message) {
@@ skipping 40 matching lines @@
   const pb::RpcMessage* received_rpc() const { return received_rpc_.get(); }
 
  private:
   std::unique_ptr<pb::RpcMessage> received_rpc_;
   int has_received_message_;
   base::WeakPtrFactory<FakeMessageReceiver> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeMessageReceiver);
 };
 
+}  // namespace
+
 class RpcBrokerTest : public testing::Test {
  protected:
   void SetUp() override {}
 };
 
 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteRegistered) {
   std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
   ASSERT_FALSE(fake_receiver->has_received_message());
 
   // Creates receiver RpcBroker and registers FakeMessageReceiver.
   std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind(
       &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
 
   int handle = rpc_broker->GetUniqueHandle();
-  const remoting::RpcBroker::ReceiveMessageCallback receive_callback =
-      base::Bind(&FakeMessageReceiver::OnReceivedRpc,
-                 fake_receiver->GetWeakPtr());
+  const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind(
+      &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr());
   rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
 
   std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
   rpc->set_handle(handle);
   rpc_broker->ProcessMessageFromRemote(std::move(rpc));
   ASSERT_EQ(fake_receiver->has_received_message(), 1);
 }
 
 TEST_F(RpcBrokerTest, TestProcessMessageFromRemoteUnregistered) {
   std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
   ASSERT_FALSE(fake_receiver->has_received_message());
 
   // Creates receiver RpcBroker and registers FakeMessageReceiver.
   std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind(
       &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
 
   int handle = rpc_broker->GetUniqueHandle();
-  const remoting::RpcBroker::ReceiveMessageCallback receive_callback =
-      base::Bind(&FakeMessageReceiver::OnReceivedRpc,
-                 fake_receiver->GetWeakPtr());
+  const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind(
+      &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr());
   rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
 
   std::unique_ptr<pb::RpcMessage> rpc(new pb::RpcMessage());
   rpc_broker->UnregisterMessageReceiverCallback(handle);
   rpc_broker->ProcessMessageFromRemote(std::move(rpc));
   ASSERT_EQ(fake_receiver->has_received_message(), 0);
 }
 
 TEST_F(RpcBrokerTest, TestSendMessageToRemote) {
   std::unique_ptr<base::MessageLoop> message_loop(new base::MessageLoop());
@@ skipping 42 matching lines @@
 }
 
 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithRegisteredHandle) {
   std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
   ASSERT_FALSE(fake_receiver->has_received_message());
 
   // Creates receiver RpcBroker and registers FakeMessageReceiver.
   std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind(
       &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
   int handle = rpc_broker->GetUniqueHandle();
-  const remoting::RpcBroker::ReceiveMessageCallback receive_callback =
-      base::Bind(&FakeMessageReceiver::OnReceivedRpc,
-                 fake_receiver->GetWeakPtr());
+  const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind(
+      &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr());
   rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
 
   // Generates RPC message with handle value |handle| and send it to receover
   // RpcBroker to process.
   std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage());
   sent_rpc->set_handle(handle);
   sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME);
   sent_rpc->set_double_value(2.2);
   rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc));
 
   // Checks if received message is identical to the one sent earlier.
   ASSERT_TRUE(fake_receiver->has_received_message());
   auto* received_rpc = fake_receiver->received_rpc();
   ASSERT_EQ(handle, received_rpc->handle());
   ASSERT_EQ(pb::RpcMessage::RPC_R_SETVOLUME, received_rpc->proc());
   ASSERT_EQ(2.2, received_rpc->double_value());
 
   // Unregisters FakeMessageReceiver.
   rpc_broker->UnregisterMessageReceiverCallback(handle);
 }
 
 TEST_F(RpcBrokerTest, RpcBrokerProcessMessageWithUnregisteredHandle) {
   std::unique_ptr<FakeMessageReceiver> fake_receiver(new FakeMessageReceiver());
   ASSERT_FALSE(fake_receiver->has_received_message());
 
   // Creates receiver RpcBroker and registers FakeMessageReceiver.
   std::unique_ptr<RpcBroker> rpc_broker(new RpcBroker(base::Bind(
       &FakeMessageReceiver::OnSendMessage, fake_receiver->GetWeakPtr())));
   int handle = rpc_broker->GetUniqueHandle();
-  const remoting::RpcBroker::ReceiveMessageCallback receive_callback =
-      base::Bind(&FakeMessageReceiver::OnReceivedRpc,
-                 fake_receiver->GetWeakPtr());
+  const RpcBroker::ReceiveMessageCallback receive_callback = base::Bind(
+      &FakeMessageReceiver::OnReceivedRpc, fake_receiver->GetWeakPtr());
   rpc_broker->RegisterMessageReceiverCallback(handle, receive_callback);
 
   // Generates RPC message with handle value |handle| and send it to receover
   // RpcBroker to process.
   std::unique_ptr<pb::RpcMessage> sent_rpc(new pb::RpcMessage());
   int different_handle = handle + 1;
   sent_rpc->set_handle(different_handle);
   sent_rpc->set_proc(pb::RpcMessage::RPC_R_SETVOLUME);
   sent_rpc->set_double_value(2.2);
   rpc_broker->ProcessMessageFromRemote(std::move(sent_rpc));
 
   // Check if received message is identical to the one sent earlier.
   ASSERT_FALSE(fake_receiver->has_received_message());
 
   // Unregisters FakeMessageReceiver.
   rpc_broker->UnregisterMessageReceiverCallback(handle);
 }
 
 }  // namespace remoting
 }  // namespace media