[cast_channel] Implement CastSocketService::OpenSocket()

components/cast_channel/cast_socket_service_unittest.cc

 // Copyright 2014 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 "components/cast_channel/cast_socket_service.h"
+#include "base/test/mock_callback.h"
 #include "components/cast_channel/cast_test_util.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
+using testing::DoAll;
+using testing::Invoke;
+using testing::Return;
 using testing::SaveArg;
 
 namespace cast_channel {
 
 class CastSocketServiceTest : public testing::Test {
  public:
   CastSocketServiceTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
         cast_socket_service_(new CastSocketService()) {}
 
+  int AddSocket(std::unique_ptr<CastSocket> socket) {
+    return cast_socket_service_->AddSocketRecord(
+        std::move(socket), mock_on_open_callback_.Get(),
+        &pass_through_message_handler_);
+  }
+
+  void TearDown() override { cast_socket_service_ = nullptr; }
+
  protected:
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_refptr<CastSocketService> cast_socket_service_;
+  base::MockCallback<CastSocketService::OnOpenCallback> mock_on_open_callback_;
+  PassThroughMessageHandler pass_through_message_handler_;
 };
 
 TEST_F(CastSocketServiceTest, TestAddSocket) {
-  int channel_id_1 = 0;
   auto socket1 = base::MakeUnique<MockCastSocket>();
-  EXPECT_CALL(*socket1, set_id(_)).WillOnce(SaveArg<0>(&channel_id_1));
-
-  int channel_id = cast_socket_service_->AddSocket(std::move(socket1));
-  EXPECT_EQ(channel_id_1, channel_id);
+  int channel_id_1 = AddSocket(std::move(socket1));
   EXPECT_NE(0, channel_id_1);
 
-  int channel_id_2 = 0;
   auto socket2 = base::MakeUnique<MockCastSocket>();
-  EXPECT_CALL(*socket2, set_id(_)).WillOnce(SaveArg<0>(&channel_id_2));
+  auto* socket_ptr = socket2.get();
+  int channel_id_2 = AddSocket(std::move(socket2));
+  EXPECT_NE(channel_id_1, channel_id_2);
+  EXPECT_CALL(mock_on_open_callback_,
+              Run(channel_id_2, ChannelError::CONNECT_ERROR));
 
-  auto* socket_ptr = socket2.get();
-  channel_id = cast_socket_service_->AddSocket(std::move(socket2));
-  EXPECT_EQ(channel_id_2, channel_id);
-  EXPECT_NE(channel_id_1, channel_id_2);
-
-  auto removed_socket = cast_socket_service_->RemoveSocket(channel_id);
+  auto removed_socket = cast_socket_service_->RemoveSocket(channel_id_2);
   EXPECT_EQ(socket_ptr, removed_socket.get());
 
-  int channel_id_3 = 0;
   auto socket3 = base::MakeUnique<MockCastSocket>();
-  EXPECT_CALL(*socket3, set_id(_)).WillOnce(SaveArg<0>(&channel_id_3));
-
-  channel_id = cast_socket_service_->AddSocket(std::move(socket3));
-  EXPECT_EQ(channel_id_3, channel_id);
+  int channel_id_3 = AddSocket(std::move(socket3));
   EXPECT_NE(channel_id_1, channel_id_3);
   EXPECT_NE(channel_id_2, channel_id_3);
 }
 
 TEST_F(CastSocketServiceTest, TestRemoveAndGetSocket) {
   int channel_id = 1;
   auto* socket_ptr = cast_socket_service_->GetSocket(channel_id);
   EXPECT_FALSE(socket_ptr);
   auto socket = cast_socket_service_->RemoveSocket(channel_id);
   EXPECT_FALSE(socket);
 
   auto mock_socket = base::MakeUnique<MockCastSocket>();
-  EXPECT_CALL(*mock_socket, set_id(_));
 
   auto* mock_socket_ptr = mock_socket.get();
-  channel_id = cast_socket_service_->AddSocket(std::move(mock_socket));
+  channel_id = AddSocket(std::move(mock_socket));
   EXPECT_EQ(mock_socket_ptr, cast_socket_service_->GetSocket(channel_id));
+  EXPECT_CALL(mock_on_open_callback_,
+              Run(channel_id, ChannelError::CONNECT_ERROR));
+
   socket = cast_socket_service_->RemoveSocket(channel_id);
   EXPECT_TRUE(socket);
 }
 
+TEST_F(CastSocketServiceTest, TestOpenChannel) {
+  base::Callback<void(ChannelError)> callback;
+  auto socket = base::MakeUnique<MockCastSocket>();
+  EXPECT_CALL(*socket, ConnectRawPtr(_, _)).WillOnce(SaveArg<1>(&callback));
+
+  auto ip_endpoint = CreateIPEndPointForTest();
+  socket->SetIPEndpoint(ip_endpoint);
+  cast_socket_service_->SetSocketForTest(std::move(socket));
+
+  base::MockCallback<CastSocketService::OnOpenCallback> mock_on_open_callback_;
+  int channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+
+  EXPECT_CALL(mock_on_open_callback_, Run(channel_id, ChannelError::NONE));
+  callback.Run(ChannelError::NONE);
+}
+
+TEST_F(CastSocketServiceTest, TestOpenChannelConnectingSocketExists) {
+  base::Callback<void(ChannelError)> callback;
+  auto socket = base::MakeUnique<MockCastSocket>();
+
+  EXPECT_CALL(*socket, ConnectRawPtr(_, _)).WillOnce(SaveArg<1>(&callback));
+  EXPECT_CALL(*socket, ready_state()).WillOnce(Return(ReadyState::CONNECTING));
+
+  auto ip_endpoint = CreateIPEndPointForTest();
+  socket->SetIPEndpoint(ip_endpoint);
+  cast_socket_service_->SetSocketForTest(std::move(socket));
+
+  base::MockCallback<CastSocketService::OnOpenCallback> mock_on_open_callback_;
+  int channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+  // Stores pending OnOpen callback.
+  int second_channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+
+  EXPECT_EQ(channel_id, second_channel_id);
+
+  // Invokes all pending callbacks.
+  EXPECT_CALL(mock_on_open_callback_, Run(channel_id, ChannelError::NONE))
+      .Times(2);
+  callback.Run(ChannelError::NONE);
+}
+
+TEST_F(CastSocketServiceTest, TestOpenChannelConnectedSocketExists) {
+  auto socket = base::MakeUnique<MockCastSocket>();
+
+  EXPECT_CALL(*socket, ConnectRawPtr(_, _));
+  EXPECT_CALL(*socket, ready_state()).WillOnce(Return(ReadyState::OPEN));
+
+  auto ip_endpoint = CreateIPEndPointForTest();
+  socket->SetIPEndpoint(ip_endpoint);
+  cast_socket_service_->SetSocketForTest(std::move(socket));
+
+  base::MockCallback<CastSocketService::OnOpenCallback> mock_on_open_callback_;
+  int channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+
+  // Invokes callback directly.
+  EXPECT_CALL(mock_on_open_callback_, Run(channel_id, ChannelError::NONE));
+  int second_channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+
+  EXPECT_EQ(channel_id, second_channel_id);
+}
+
+TEST_F(CastSocketServiceTest, TestOpenChannelClosedSocketExists) {
+  auto socket1 = base::MakeUnique<MockCastSocket>();
+
+  EXPECT_CALL(*socket1, ConnectRawPtr(_, _));
+  EXPECT_CALL(*socket1, ready_state()).WillOnce(Return(ReadyState::CLOSED));
+
+  auto ip_endpoint = CreateIPEndPointForTest();
+  socket1->SetIPEndpoint(ip_endpoint);
+  cast_socket_service_->SetSocketForTest(std::move(socket1));
+
+  base::MockCallback<CastSocketService::OnOpenCallback> mock_on_open_callback_;
+  int channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+
+  base::Callback<void(ChannelError)> callback2;
+  auto socket2 = base::MakeUnique<MockCastSocket>();
+
+  EXPECT_CALL(*socket2, ConnectRawPtr(_, _));
+  cast_socket_service_->SetSocketForTest(std::move(socket2));
+
+  EXPECT_CALL(mock_on_open_callback_,
+              Run(channel_id, ChannelError::CONNECT_ERROR));
+  // This call will release |socket1|.
+  int second_channel_id = cast_socket_service_->OpenSocket(
+      ip_endpoint, nullptr /* net_log */, mock_on_open_callback_.Get());
+
+  EXPECT_NE(channel_id, second_channel_id);
+}
+
+TEST_F(CastSocketServiceTest, TestRegisterDelegate) {
+  EXPECT_FALSE(cast_socket_service_->RegisterDelegate(
+      1, base::MakeUnique<MockCastTransportDelegate>()));
+
+  auto socket = base::MakeUnique<MockCastSocket>();
+  int channel_id = AddSocket(std::move(socket));
+
+  auto* mock_delegate = new MockCastTransportDelegate();
+  EXPECT_TRUE(cast_socket_service_->RegisterDelegate(
+      channel_id, base::WrapUnique(mock_delegate)));
+  EXPECT_EQ(mock_delegate, pass_through_message_handler_.inner_delegate_.get());
+}
+
 }  // namespace cast_channel