[MediaRouter] Replace RouteMessage with PresentationConnectionMessage

chrome/browser/media/cast_remoting_connector_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 "chrome/browser/media/cast_remoting_connector.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "chrome/browser/media/router/media_routes_observer.h"
 #include "chrome/browser/media/router/mock_media_router.h"
 #include "chrome/browser/media/router/route_message_observer.h"
+#include "chrome/browser/media/router/test_helper.h"
 #include "chrome/common/media_router/media_route.h"
 #include "chrome/common/media_router/media_source.h"
-#include "chrome/common/media_router/route_message.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/common/presentation_connection_message.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "media/mojo/interfaces/remoting.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
+using content::PresentationConnectionMessage;
 
 using media::mojom::RemoterPtr;
 using media::mojom::RemoterRequest;
 using media::mojom::RemotingSinkCapabilities;
 using media::mojom::RemotingSourcePtr;
 using media::mojom::RemotingSourceRequest;
 using media::mojom::RemotingStartFailReason;
 using media::mojom::RemotingStopReason;
 
 using media_router::MediaRoutesObserver;
 using media_router::MediaRoute;
 using media_router::MediaSource;
-using media_router::RouteMessage;
+using media_router::PresentationConnectionMessageToString;
 using media_router::RouteMessageObserver;
 
 using ::testing::_;
 using ::testing::AtLeast;
 
 namespace {
 
 constexpr char kRemotingMediaSource[] =
     "urn:x-org.chromium.media:source:tab_content_remoting:123";
 constexpr char kRemotingMediaSink[] = "wiggles";
@@ skipping 45 matching lines @@
       }
       outbound_messages_.clear();
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             base::BindOnce(&FakeMediaRouter::DoUpdateRoutes,
                                            weak_factory_.GetWeakPtr()));
   }
 
   void OnMessageFromProvider(const std::string& message) {
-    inbound_messages_.push_back(RouteMessage());
-    inbound_messages_.back().type = RouteMessage::TEXT;
-    inbound_messages_.back().text = message;
+    inbound_messages_.emplace_back(message);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::BindOnce(&FakeMediaRouter::DoDeliverInboundMessages,
                        weak_factory_.GetWeakPtr()));
   }
 
   void OnBinaryMessageFromProvider(const std::vector<uint8_t>& message) {
-    inbound_messages_.push_back(RouteMessage());
-    inbound_messages_.back().type = RouteMessage::BINARY;
-    inbound_messages_.back().binary = std::vector<uint8_t>(message);
+    inbound_messages_.emplace_back(message);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::BindOnce(&FakeMediaRouter::DoDeliverInboundMessages,
                        weak_factory_.GetWeakPtr()));
   }
 
-  void TakeMessagesSentToProvider(RouteMessage::Type type,
-                                  std::vector<RouteMessage>* messages) {
+  void TakeMessagesSentToProvider(
+      bool text,
+      std::vector<PresentationConnectionMessage>* messages) {
     decltype(outbound_messages_) untaken_messages;
     for (auto& entry : outbound_messages_) {
-      if (entry.first.type == type) {
+      if (!entry.first.is_binary() == text) {
         messages->push_back(entry.first);
         BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                                 base::BindOnce(std::move(entry.second), true));
       } else {
         untaken_messages.push_back(std::move(entry));
       }
     }
     outbound_messages_.swap(untaken_messages);
   }
 
@@ skipping 21 matching lines @@
   void UnregisterRouteMessageObserver(RouteMessageObserver* observer) final {
     CHECK_EQ(message_observer_, observer);
     message_observer_ = nullptr;
   }
 
   void SendRouteMessage(const MediaRoute::Id& route_id,
                         const std::string& text,
                         SendRouteMessageCallback callback) final {
     EXPECT_EQ(message_observer_->route_id(), route_id);
     ASSERT_FALSE(callback.is_null());
-    RouteMessage message;
-    message.type = RouteMessage::TEXT;
-    message.text = text;
-    outbound_messages_.push_back(std::make_pair(message, std::move(callback)));
+    PresentationConnectionMessage message(text);
+    outbound_messages_.emplace_back(std::move(message), std::move(callback));
   }
 
   void SendRouteBinaryMessage(const MediaRoute::Id& route_id,
                               std::unique_ptr<std::vector<uint8_t>> data,
                               SendRouteMessageCallback callback) final {
     EXPECT_EQ(message_observer_->route_id(), route_id);
     ASSERT_TRUE(!!data);
     ASSERT_FALSE(callback.is_null());
-    RouteMessage message;
-    message.type = RouteMessage::BINARY;
-    message.binary = std::move(*data);
-    outbound_messages_.push_back(std::make_pair(message, std::move(callback)));
+    PresentationConnectionMessage message(std::move(*data));
+    outbound_messages_.emplace_back(std::move(message), std::move(callback));
   }
 
  private:
   // Asynchronous callback to notify the MediaRoutesObserver of a change in
   // routes.
   void DoUpdateRoutes() {
     if (routes_observer_)
       routes_observer_->OnRoutesUpdated(routes_, std::vector<MediaRoute::Id>());
   }
 
   // Asynchronous callback to deliver messages to the RouteMessageObserver.
   void DoDeliverInboundMessages() {
     if (message_observer_)
       message_observer_->OnMessagesReceived(inbound_messages_);
     inbound_messages_.clear();
   }
 
   MediaRoutesObserver* routes_observer_;
   RouteMessageObserver* message_observer_;
 
   std::vector<MediaRoute> routes_;
   // Messages from Cast Provider to the connector.
-  std::vector<RouteMessage> inbound_messages_;
+  std::vector<PresentationConnectionMessage> inbound_messages_;
   // Messages from the connector to the Cast Provider.
   using OutboundMessageAndCallback =
-      std::pair<RouteMessage, SendRouteMessageCallback>;
+      std::pair<PresentationConnectionMessage, SendRouteMessageCallback>;
   std::vector<OutboundMessageAndCallback> outbound_messages_;
 
   base::WeakPtrFactory<FakeMediaRouter> weak_factory_;
 };
 
 class MockRemotingSource : public media::mojom::RemotingSource {
  public:
   MockRemotingSource() : binding_(this) {}
   ~MockRemotingSource() final {}
 
@@ skipping 42 matching lines @@
 
   void ProviderDiscoversSink() {
     media_router_.OnRemotingRouteExists(true);
   }
 
   void ProviderLosesSink() {
     media_router_.OnRemotingRouteExists(false);
   }
 
   void ConnectorSentMessageToProvider(const std::string& expected_message) {
-    std::vector<RouteMessage> messages;
-    media_router_.TakeMessagesSentToProvider(RouteMessage::TEXT, &messages);
+    std::vector<PresentationConnectionMessage> messages;
+    media_router_.TakeMessagesSentToProvider(true, &messages);
     bool did_see_expected_message = false;
-    for (const RouteMessage& message : messages) {
-      if (message.text && expected_message == *message.text) {
+    for (const auto& message : messages) {
+      if (expected_message == message.message) {
         did_see_expected_message = true;
       } else {
-        ADD_FAILURE()
-            << "Unexpected message: " << message.ToHumanReadableString();
+        ADD_FAILURE() << "Unexpected message: "
+                      << PresentationConnectionMessageToString(message);
       }
     }
     EXPECT_TRUE(did_see_expected_message);
   }
 
   void ConnectorSentMessageToSink(
       const std::vector<uint8_t>& expected_message) {
-    std::vector<RouteMessage> messages;
-    media_router_.TakeMessagesSentToProvider(RouteMessage::BINARY, &messages);
+    std::vector<PresentationConnectionMessage> messages;
+    media_router_.TakeMessagesSentToProvider(false, &messages);
     bool did_see_expected_message = false;
-    for (const RouteMessage& message : messages) {
-      if (message.binary && expected_message == *message.binary) {
+    for (const auto& message : messages) {
+      if (expected_message == message.data) {
         did_see_expected_message = true;
       } else {
-        ADD_FAILURE()
-            << "Unexpected message: " << message.ToHumanReadableString();
+        ADD_FAILURE() << "Unexpected message: "
+                      << PresentationConnectionMessageToString(message);
       }
     }
     EXPECT_TRUE(did_see_expected_message);
   }
 
   void ConnectorSentNoMessagesToProvider() {
-    std::vector<RouteMessage> messages;
-    media_router_.TakeMessagesSentToProvider(RouteMessage::TEXT, &messages);
+    std::vector<PresentationConnectionMessage> messages;
+    media_router_.TakeMessagesSentToProvider(true, &messages);
     EXPECT_TRUE(messages.empty());
   }
 
   void ConnectorSentNoMessagesToSink() {
-    std::vector<RouteMessage> messages;
-    media_router_.TakeMessagesSentToProvider(RouteMessage::BINARY, &messages);
+    std::vector<PresentationConnectionMessage> messages;
+    media_router_.TakeMessagesSentToProvider(false, &messages);
     EXPECT_TRUE(messages.empty());
   }
 
   void ProviderPassesMessageFromSink(
       const std::vector<uint8_t>& message) {
     media_router_.OnBinaryMessageFromProvider(message);
   }
 
   void ProviderSaysToRemotingConnector(const std::string& message) {
     media_router_.OnMessageFromProvider(message);
@@ skipping 284 matching lines @@
       break;
     }
   }
 }
 
 INSTANTIATE_TEST_CASE_P(, CastRemotingConnectorFullSessionTest,
                         ::testing::Values(SOURCE_TERMINATES,
                                           MOJO_PIPE_CLOSES,
                                           ROUTE_TERMINATES,
                                           EXTERNAL_FAILURE));