[MediaRouter] Replace RouteMessage with PresentationConnectionMessage

chrome/browser/media/router/mojo/media_router_mojo_impl_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 10 matching lines @@
 #include "chrome/browser/media/router/event_page_request_manager.h"
 #include "chrome/browser/media/router/event_page_request_manager_factory.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_metrics.h"
 #include "chrome/browser/media/router/mojo/media_router_mojo_test.h"
 #include "chrome/browser/media/router/route_message_observer.h"
 #include "chrome/browser/media/router/test_helper.h"
 #include "chrome/common/media_router/issue.h"
 #include "chrome/common/media_router/media_route.h"
 #include "chrome/common/media_router/media_source_helper.h"
-#include "chrome/common/media_router/route_message.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "components/version_info/version_info.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_factory.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_builder.h"
@@ skipping 963 matching lines @@
       kRouteId, std::move(expected_binary_data),
       base::Bind(&SendMessageCallbackHandler::Invoke,
                  base::Unretained(&handler)));
   run_loop.Run();
 }
 
 namespace {
 
 // Used in the RouteMessages* tests to populate the messages that will be
 // processed and dispatched to RouteMessageObservers.
-void PopulateRouteMessages(std::vector<RouteMessage>* batch1,
-                           std::vector<RouteMessage>* batch2,
-                           std::vector<RouteMessage>* batch3) {
-  batch1->resize(1);
-  batch1->at(0).type = RouteMessage::TEXT;
-  batch1->at(0).text = std::string("text1");
-  batch2->resize(2);
-  batch2->at(0).type = RouteMessage::BINARY;
-  batch2->at(0).binary = std::vector<uint8_t>(1, UINT8_C(1));
-  batch2->at(1).type = RouteMessage::TEXT;
-  batch2->at(1).text = std::string("text2");
-  batch3->resize(3);
-  batch3->at(0).type = RouteMessage::TEXT;
-  batch3->at(0).text = std::string("text3");
-  batch3->at(1).type = RouteMessage::BINARY;
-  batch3->at(1).binary = std::vector<uint8_t>(1, UINT8_C(2));
-  batch3->at(2).type = RouteMessage::BINARY;
-  batch3->at(2).binary = std::vector<uint8_t>(1, UINT8_C(3));
+void PopulateRouteMessages(
+    std::vector<content::PresentationConnectionMessage>* batch1,
+    std::vector<content::PresentationConnectionMessage>* batch2,
+    std::vector<content::PresentationConnectionMessage>* batch3,
+    std::vector<content::PresentationConnectionMessage>* all_messages) {
+  batch1->clear();
+  batch2->clear();
+  batch3->clear();
+  batch1->emplace_back("text1");
+  batch2->emplace_back(std::vector<uint8_t>(1, UINT8_C(1)));
+  batch2->emplace_back("text2");
+  batch3->emplace_back("text3");
+  batch3->emplace_back(std::vector<uint8_t>(1, UINT8_C(2)));
+  batch3->emplace_back(std::vector<uint8_t>(1, UINT8_C(3)));
+  all_messages->clear();
+  all_messages->insert(all_messages->end(), batch1->begin(), batch1->end());
+  all_messages->insert(all_messages->end(), batch2->begin(), batch2->end());
+  all_messages->insert(all_messages->end(), batch3->begin(), batch3->end());
 }
 
 // Used in the RouteMessages* tests to observe and sanity-check that the
 // messages being received from the router are correct and in-sequence. The
 // checks here correspond to the expected messages in PopulateRouteMessages()
 // above.
 class ExpectedMessagesObserver : public RouteMessageObserver {
  public:
-  ExpectedMessagesObserver(MediaRouter* router, const MediaRoute::Id& route_id)
-      : RouteMessageObserver(router, route_id) {}
+  ExpectedMessagesObserver(
+      MediaRouter* router,
+      const MediaRoute::Id& route_id,
+      const std::vector<content::PresentationConnectionMessage>&
+          expected_messages)
+      : RouteMessageObserver(router, route_id),
+        expected_messages_(expected_messages) {}
 
   ~ExpectedMessagesObserver() final {
     CheckReceivedMessages();
   }
 
  private:
   void OnMessagesReceived(
-      const std::vector<RouteMessage>& messages) final {
+      const std::vector<content::PresentationConnectionMessage>& messages)
+      final {
     messages_.insert(messages_.end(), messages.begin(), messages.end());
   }
 
   void CheckReceivedMessages() {
-    ASSERT_EQ(6u, messages_.size());
-    EXPECT_EQ(RouteMessage::TEXT, messages_[0].type);
-    ASSERT_TRUE(messages_[0].text);
-    EXPECT_EQ("text1", *messages_[0].text);
-    EXPECT_EQ(RouteMessage::BINARY, messages_[1].type);
-    ASSERT_TRUE(messages_[1].binary);
-    ASSERT_EQ(1u, messages_[1].binary->size());
-    EXPECT_EQ(UINT8_C(1), messages_[1].binary->front());
-    EXPECT_EQ(RouteMessage::TEXT, messages_[2].type);
-    ASSERT_TRUE(messages_[2].text);
-    EXPECT_EQ("text2", *messages_[2].text);
-    EXPECT_EQ(RouteMessage::TEXT, messages_[3].type);
-    ASSERT_TRUE(messages_[3].text);
-    EXPECT_EQ("text3", *messages_[3].text);
-    EXPECT_EQ(RouteMessage::BINARY, messages_[4].type);
-    ASSERT_TRUE(messages_[4].binary);
-    ASSERT_EQ(1u, messages_[4].binary->size());
-    EXPECT_EQ(UINT8_C(2), messages_[4].binary->front());
-    EXPECT_EQ(RouteMessage::BINARY, messages_[5].type);
-    ASSERT_TRUE(messages_[5].binary);
-    ASSERT_EQ(1u, messages_[5].binary->size());
-    EXPECT_EQ(UINT8_C(3), messages_[5].binary->front());
+    ASSERT_EQ(expected_messages_.size(), messages_.size());
+    for (size_t i = 0; i < expected_messages_.size(); i++) {
+      EXPECT_EQ(expected_messages_[i], messages_[i])
+          << "Message mismatch at index " << i << ": expected: "
+          << PresentationConnectionMessageToString(expected_messages_[i])
+          << ", actual: "
+          << PresentationConnectionMessageToString(messages_[i]);
+    }
   }
 
-  std::vector<RouteMessage> messages_;
+  std::vector<content::PresentationConnectionMessage> expected_messages_;
+  std::vector<content::PresentationConnectionMessage> messages_;
 };
 
 class NullMessageObserver : public RouteMessageObserver {
  public:
   NullMessageObserver(MediaRouter* router, const MediaRoute::Id& route_id)
       : RouteMessageObserver(router, route_id) {}
   ~NullMessageObserver() final {}
 
-  void OnMessagesReceived(const std::vector<RouteMessage>& messages) final {}
+  void OnMessagesReceived(
+      const std::vector<content::PresentationConnectionMessage>& messages)
+      final {}
 };
 
 }  // namespace
 
 TEST_F(MediaRouterMojoImplTest, RouteMessagesSingleObserver) {
-  std::vector<RouteMessage> incoming_batch1, incoming_batch2, incoming_batch3;
-  PopulateRouteMessages(&incoming_batch1, &incoming_batch2, &incoming_batch3);
+  std::vector<content::PresentationConnectionMessage> incoming_batch1,
+      incoming_batch2, incoming_batch3, all_messages;
+  PopulateRouteMessages(&incoming_batch1, &incoming_batch2, &incoming_batch3,
+                        &all_messages);
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   EXPECT_CALL(mock_media_route_provider_,
               StartListeningForRouteMessages(Eq(expected_route_id)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
 
   // Creating ExpectedMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
-  ExpectedMessagesObserver observer(router(), expected_route_id);
+  ExpectedMessagesObserver observer(router(), expected_route_id, all_messages);
   run_loop.Run();  // Will quit when StartListeningForRouteMessages() is called.
   router()->OnRouteMessagesReceived(expected_route_id, incoming_batch1);
   router()->OnRouteMessagesReceived(expected_route_id, incoming_batch2);
   router()->OnRouteMessagesReceived(expected_route_id, incoming_batch3);
   // When |observer| goes out-of-scope, its destructor will ensure all expected
   // messages have been received.
 }
 
 TEST_F(MediaRouterMojoImplTest, RouteMessagesMultipleObservers) {
-  std::vector<RouteMessage> incoming_batch1, incoming_batch2, incoming_batch3;
-  PopulateRouteMessages(&incoming_batch1, &incoming_batch2, &incoming_batch3);
+  std::vector<content::PresentationConnectionMessage> incoming_batch1,
+      incoming_batch2, incoming_batch3, all_messages;
+  PopulateRouteMessages(&incoming_batch1, &incoming_batch2, &incoming_batch3,
+                        &all_messages);
 
   base::RunLoop run_loop;
   MediaRoute::Id expected_route_id("foo");
   EXPECT_CALL(mock_media_route_provider_,
               StartListeningForRouteMessages(Eq(expected_route_id)))
       .WillOnce(InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
 
   // The ExpectedMessagesObservers will register themselves with the
   // MediaRouter, which in turn will start listening for route messages.
-  ExpectedMessagesObserver observer1(router(), expected_route_id);
-  ExpectedMessagesObserver observer2(router(), expected_route_id);
+  ExpectedMessagesObserver observer1(router(), expected_route_id, all_messages);
+  ExpectedMessagesObserver observer2(router(), expected_route_id, all_messages);
   run_loop.Run();  // Will quit when StartListeningForRouteMessages() is called.
   router()->OnRouteMessagesReceived(expected_route_id, incoming_batch1);
   router()->OnRouteMessagesReceived(expected_route_id, incoming_batch2);
   router()->OnRouteMessagesReceived(expected_route_id, incoming_batch3);
   // As each |observer| goes out-of-scope, its destructor will ensure all
   // expected messages have been received.
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationConnectionStateChangedCallback) {
   MediaRoute::Id route_id("route-id");
@@ skipping 468 matching lines @@
     EXPECT_CALL(mock_media_route_provider_,
                 StartListeningForRouteMessages(media_source.id()));
     media_router_->OnConnectionError();
     BindMediaRouteProvider();
     RegisterMediaRouteProvider();
     base::RunLoop().RunUntilIdle();
   }
 }
 
 }  // namespace media_router