[Presentation API] 1-UA presentation support + presenter APIs.

chrome/browser/media/router/offscreen_presentation_manager_unittest.cc

Index: chrome/browser/media/router/offscreen_presentation_manager_unittest.cc
diff --git a/chrome/browser/media/router/offscreen_presentation_manager_unittest.cc b/chrome/browser/media/router/offscreen_presentation_manager_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..84d47bd2e54ea7f59c193f6b56f7b5bd1cef4f5a
--- /dev/null
+++ b/chrome/browser/media/router/offscreen_presentation_manager_unittest.cc
@@ -0,0 +1,241 @@
+// 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 <vector>
+
+#include "base/bind.h"
+#include "chrome/browser/media/router/offscreen_presentation_manager.h"
+#include "chrome/browser/media/router/test_helper.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using testing::_;
+
+namespace media_router {
+
+using OffscreenPresentationConnection =
+    OffscreenPresentationManager::OffscreenPresentationConnection;
+
+namespace {
+const char kPresentationId[] = "presentationId";
+
+}  // namespace
+
+class OffscreenPresentationManagerTest : public ::testing::Test {
+ public:
+  void OnReceiverConnectionAvailable(
+      std::unique_ptr<OffscreenPresentationConnection> connection) {
+    ASSERT_TRUE(connection);
+    receivers_.push_back(std::move(connection));
+  }
+
+  OffscreenPresentationManager* manager() { return &manager_; }
+  std::vector<std::unique_ptr<OffscreenPresentationConnection>>* receivers() {
+    return &receivers_;
+  }
+
+  MockPresentationConnectionStateChangedCallback*
+  mock_controller_state_change_callback() {
+    return &mock_controller_state_change_callback_;
+  }
+  MockPresentationConnectionStateChangedCallback*
+  mock_receiver_state_change_callback() {
+    return &mock_receiver_state_change_callback_;
+  }
+  MockPresentationMessagesCallback* mock_controller_messages_callback() {
+    return &mock_controller_messages_callback_;
+  }
+  MockPresentationMessagesCallback* mock_receiver_messages_callback() {
+    return &mock_receiver_messages_callback_;
+  }
+
+ private:
+  OffscreenPresentationManager manager_;
+  std::vector<std::unique_ptr<OffscreenPresentationConnection>> receivers_;
+  MockPresentationConnectionStateChangedCallback
+      mock_controller_state_change_callback_;
+  MockPresentationConnectionStateChangedCallback
+      mock_receiver_state_change_callback_;
+  MockPresentationMessagesCallback mock_controller_messages_callback_;
+  MockPresentationMessagesCallback mock_receiver_messages_callback_;
+};
+
+TEST_F(OffscreenPresentationManagerTest, RegisterReceiver) {
+  RenderFrameHostId controller_rfh_id(123, 456);
+  // Receiver hasn't registered yet.
+  EXPECT_FALSE(manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                         controller_rfh_id));
+
+  manager()->RegisterOffscreenPresentationReceiver(
+      kPresentationId,
+      base::Bind(
+          &OffscreenPresentationManagerTest::OnReceiverConnectionAvailable,
+          base::Unretained(this)));
+
+  // Registered receiver, but controller hasn't connected yet.
+  EXPECT_EQ(0u, receivers()->size());
+
+  std::unique_ptr<OffscreenPresentationConnection> controller_connection =
+      manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                controller_rfh_id);
+  EXPECT_TRUE(controller_connection);
+  EXPECT_EQ(1u, receivers()->size());
+
+  // A frame can only have one OffscreenPresentationConnection at a time.
+  EXPECT_FALSE(manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                         controller_rfh_id));
+
+  RenderFrameHostId controller_rfh_id2(234, 567);
+  std::unique_ptr<OffscreenPresentationConnection> controller_connection2 =
+      manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                controller_rfh_id2);
+  EXPECT_TRUE(controller_connection2);
+  EXPECT_EQ(2u, receivers()->size());
+
+  // All connections must be destroyed before unregistering receiver.
+  receivers()->clear();
+  manager()->UnregisterOffscreenPresentationReceiver(kPresentationId);
+
+  // Receiver has unregistered, so controller can't connect anymore.
+  RenderFrameHostId controller_rfh_id3(345, 678);
+  EXPECT_FALSE(manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                         controller_rfh_id3));
+}
+
+TEST_F(OffscreenPresentationManagerTest, ReceiverListenForStateChange) {
+  manager()->RegisterOffscreenPresentationReceiver(
+      kPresentationId,
+      base::Bind(
+          &OffscreenPresentationManagerTest::OnReceiverConnectionAvailable,
+          base::Unretained(this)));
+
+  RenderFrameHostId controller_rfh_id(123, 456);
+  std::unique_ptr<OffscreenPresentationConnection> controller_connection =
+      manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                controller_rfh_id);
+  ASSERT_TRUE(controller_connection);
+  ASSERT_EQ(1u, receivers()->size());
+
+  (*receivers())[0]->ListenForStateChange(
+      base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                 base::Unretained(mock_receiver_state_change_callback())));
+  controller_connection->ListenForStateChange(
+      base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                 base::Unretained(mock_controller_state_change_callback())));
+
+  content::PresentationConnectionStateChangeInfo info(
+      content::PRESENTATION_CONNECTION_STATE_TERMINATED);
+  EXPECT_CALL(*mock_receiver_state_change_callback(),
+              Run(StateChageInfoEquals(info)));
+  EXPECT_CALL(*mock_controller_state_change_callback(), Run(_)).Times(0);
+  controller_connection->RemoveFromPresentation(info);
+}
+
+TEST_F(OffscreenPresentationManagerTest, ControllerListenForStateChange) {
+  manager()->RegisterOffscreenPresentationReceiver(
+      kPresentationId,
+      base::Bind(
+          &OffscreenPresentationManagerTest::OnReceiverConnectionAvailable,
+          base::Unretained(this)));
+
+  RenderFrameHostId controller_rfh_id(123, 456);
+  std::unique_ptr<OffscreenPresentationConnection> controller_connection =
+      manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                controller_rfh_id);
+  ASSERT_TRUE(controller_connection);
+  ASSERT_EQ(1u, receivers()->size());
+
+  (*receivers())[0]->ListenForStateChange(
+      base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                 base::Unretained(mock_receiver_state_change_callback())));
+  controller_connection->ListenForStateChange(
+      base::Bind(&MockPresentationConnectionStateChangedCallback::Run,
+                 base::Unretained(mock_controller_state_change_callback())));
+
+  // Destroying an OffscreenPresentationConnection will automatically call
+  // |RemoveFromPresentation|.
+  content::PresentationConnectionStateChangeInfo info(
+      content::PRESENTATION_CONNECTION_STATE_CLOSED);
+  info.close_reason = content::PRESENTATION_CONNECTION_CLOSE_REASON_WENT_AWAY;
+  EXPECT_CALL(*mock_controller_state_change_callback(),
+              Run(StateChageInfoEquals(info)));
+  EXPECT_CALL(*mock_receiver_state_change_callback(), Run(_)).Times(0);
+  receivers()->clear();
+}
+
+TEST_F(OffscreenPresentationManagerTest, ListenForAndSendMessages) {
+  manager()->RegisterOffscreenPresentationReceiver(
+      kPresentationId,
+      base::Bind(
+          &OffscreenPresentationManagerTest::OnReceiverConnectionAvailable,
+          base::Unretained(this)));
+
+  RenderFrameHostId controller_rfh_id(123, 456);
+  std::unique_ptr<OffscreenPresentationConnection> controller_connection =
+      manager()->ConnectToOffscreenPresentation(kPresentationId,
+                                                controller_rfh_id);
+  ASSERT_TRUE(controller_connection);
+  ASSERT_EQ(1u, receivers()->size());
+
+  (*receivers())[0]->ListenForMessages(
+      base::Bind(&MockPresentationMessagesCallback::OnMessagesReceived,
+                 base::Unretained(mock_receiver_messages_callback())));
+  controller_connection->ListenForMessages(
+      base::Bind(&MockPresentationMessagesCallback::OnMessagesReceived,
+                 base::Unretained(mock_controller_messages_callback())));
+
+  std::string sender_message_text("from controller to receiver");
+  std::unique_ptr<content::PresentationSessionMessage> message(
+      new content::PresentationSessionMessage(
+          content::PresentationMessageType::TEXT));
+  message->message = sender_message_text;
+  EXPECT_CALL(*mock_controller_messages_callback(), OnMessageSent(true));
+  EXPECT_CALL(*mock_receiver_messages_callback(),
+              DoOnMessagesReceived(sender_message_text));
+  EXPECT_CALL(*mock_controller_messages_callback(), DoOnMessagesReceived(_))
+      .Times(0);
+  controller_connection->SendMessage(
+      std::move(message),
+      base::Bind(&MockPresentationMessagesCallback::OnMessageSent,
+                 base::Unretained(mock_controller_messages_callback())));
+  EXPECT_TRUE(testing::Mock::VerifyAndClearExpectations(
+      mock_controller_messages_callback()));
+  EXPECT_TRUE(testing::Mock::VerifyAndClearExpectations(
+      mock_receiver_messages_callback()));
+
+  std::string receiver_message_text("from receiver to controller");
+  message.reset(new content::PresentationSessionMessage(
+      content::PresentationMessageType::TEXT));
+  message->message = receiver_message_text;
+  EXPECT_CALL(*mock_receiver_messages_callback(), OnMessageSent(true));
+  EXPECT_CALL(*mock_controller_messages_callback(),
+              DoOnMessagesReceived(receiver_message_text));
+  EXPECT_CALL(*mock_receiver_messages_callback(), DoOnMessagesReceived(_))
+      .Times(0);
+  (*receivers())[0]->SendMessage(
+      std::move(message),
+      base::Bind(&MockPresentationMessagesCallback::OnMessageSent,
+                 base::Unretained(mock_receiver_messages_callback())));
+  EXPECT_TRUE(testing::Mock::VerifyAndClearExpectations(
+      mock_controller_messages_callback()));
+  EXPECT_TRUE(testing::Mock::VerifyAndClearExpectations(
+      mock_receiver_messages_callback()));
+
+  // Can't send/receive messages after either side has left.
+  receivers()->clear();
+  message.reset(new content::PresentationSessionMessage(
+      content::PresentationMessageType::TEXT));
+  message->message = sender_message_text;
+  EXPECT_CALL(*mock_controller_messages_callback(), OnMessageSent(false));
+  EXPECT_CALL(*mock_receiver_messages_callback(), DoOnMessagesReceived(_))
+      .Times(0);
+  EXPECT_CALL(*mock_controller_messages_callback(), DoOnMessagesReceived(_))
+      .Times(0);
+  controller_connection->SendMessage(
+      std::move(message),
+      base::Bind(&MockPresentationMessagesCallback::OnMessageSent,
+                 base::Unretained(mock_controller_messages_callback())));
+}
+
+}  // namespace media_router