[MediaRouter] Replace RouteMessage with PresentationConnectionMessage

chrome/browser/media/router/browser_presentation_connection_proxy_unittest.cc

 // Copyright 2017 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 "chrome/browser/media/router/browser_presentation_connection_proxy.h"
 
 #include "base/run_loop.h"
 #include "base/test/mock_callback.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/common/media_router/media_source.h"
 #include "chrome/common/media_router/media_source_helper.h"
-#include "chrome/common/media_router/route_message.h"
 #include "content/public/common/presentation_connection_message.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using ::testing::_;
 using ::testing::Invoke;
 
 namespace media_router {
 
 using OnMessageCallback = BrowserPresentationConnectionProxy::OnMessageCallback;
@@ skipping 90 matching lines @@
           [&expected_data](
               const MediaRoute::Id& route_id, std::vector<uint8_t>* data,
               const BrowserPresentationConnectionProxy::OnMessageCallback&
                   callback) { EXPECT_EQ(*data, expected_data); }));
 
   browser_connection_proxy()->OnMessage(std::move(connection_message),
                                         mock_on_message_callback.Get());
 }
 
 TEST_F(BrowserPresentationConnectionProxyTest, OnMessagesReceived) {
-  RouteMessage message_1;
-  message_1.type = RouteMessage::Type::TEXT;
-  message_1.text = std::string("foo");
-  RouteMessage message_2;
-  message_2.type = RouteMessage::Type::BINARY;
-  message_2.binary = std::vector<uint8_t>({1, 2, 3});
-  std::vector<RouteMessage> messages = {message_1, message_2};
+  content::PresentationConnectionMessage message_1;

[mark a. foltz, 2017/06/28 07:29:55]

message_1("foo") etc.

[imcheng, 2017/06/29 08:21:09]

Done.

+  message_1.message = std::string("foo");
+  content::PresentationConnectionMessage message_2;
+  message_2.data = std::vector<uint8_t>({1, 2, 3});
+  std::vector<content::PresentationConnectionMessage> messages = {message_1,
+                                                                  message_2};
 
-  content::PresentationConnectionMessage expected_message1("foo");
-  content::PresentationConnectionMessage expected_message2(
-      std::vector<uint8_t>({1, 2, 3}));
   EXPECT_CALL(*controller_connection_proxy(), OnMessageInternal(_, _))
-      .WillOnce(
-          Invoke([&expected_message1](
-                     const content::PresentationConnectionMessage& message,
-                     OnMessageCallback& callback) {
-            ExpectMessageAndRunCallback(expected_message1, message, callback);
+      .WillOnce(Invoke(
+          [&message_1](const content::PresentationConnectionMessage& message,
+                       OnMessageCallback& callback) {
+            ExpectMessageAndRunCallback(message_1, message, callback);
           }))
-      .WillOnce(
-          Invoke([&expected_message2](
-                     const content::PresentationConnectionMessage& message,
-                     OnMessageCallback& callback) {
-            ExpectMessageAndRunCallback(expected_message2, message, callback);
+      .WillOnce(Invoke(
+          [&message_2](const content::PresentationConnectionMessage& message,
+                       OnMessageCallback& callback) {
+            ExpectMessageAndRunCallback(message_2, message, callback);
           }));
   browser_connection_proxy()->OnMessagesReceived(messages);
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace media_router