[cast_channel] Implement CastSocketService::OpenSocket()

components/cast_channel/cast_socket_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.h"
 
 #include <stdint.h>
 
 #include <utility>
 #include <vector>
@@ skipping 140 matching lines @@
   MOCK_METHOD0(Start, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
 };
 
 class CompleteHandler {
  public:
   CompleteHandler() {}
   MOCK_METHOD1(OnCloseComplete, void(int result));
-  MOCK_METHOD1(OnConnectComplete, void(ChannelError error_state));
+  MOCK_METHOD2(OnConnectComplete,
+               void(int channel_id, ChannelError error_state));
   MOCK_METHOD1(OnWriteComplete, void(int result));
   MOCK_METHOD1(OnReadComplete, void(int result));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CompleteHandler);
 };
 
 class TestCastSocket : public CastSocketImpl {
  public:
   static std::unique_ptr<TestCastSocket> CreateSecure(
@@ skipping 177 matching lines @@
     socket_ = TestCastSocket::CreateSecure(logger_);
   }
 
   void HandleAuthHandshake() {
     socket_->SetupMockTransport();
     CastMessage challenge_proto = CreateAuthChallenge();
     EXPECT_CALL(*socket_->GetMockTransport(),
                 SendMessage(EqualsProto(challenge_proto), _))
         .WillOnce(PostCompletionCallbackTask<1>(net::OK));
     EXPECT_CALL(*socket_->GetMockTransport(), Start());
-    EXPECT_CALL(handler_, OnConnectComplete(ChannelError::NONE));
+    EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::NONE));
     socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                                 base::Unretained(&handler_)));
     RunPendingTasks();
     socket_->GetMockTransport()->current_delegate()->OnMessage(
         CreateAuthReply());
     RunPendingTasks();
   }
 
  protected:
   // Runs all pending tasks in the message loop.
@@ skipping 55 matching lines @@
   socket_->SetupMockTransport();
 
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
 
   CastMessage challenge_proto = CreateAuthChallenge();
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(challenge_proto), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::TRANSPORT_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::TRANSPORT_ERROR));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   CastMessage mangled_auth_reply = CreateAuthReply();
   mangled_auth_reply.set_namespace_("BOGUS_NAMESPACE");
 
   socket_->GetMockTransport()->current_delegate()->OnMessage(
       mangled_auth_reply);
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::TRANSPORT_ERROR, socket_->error_state());
 
   // Verifies that the CastSocket's resources were torn down during channel
   // close. (see http://crbug.com/504078)
   EXPECT_EQ(nullptr, socket_->transport());
 }
 
 // Test connection error - TCP connect fails (async)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_ERROR));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - TCP connect fails (sync)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_ERROR));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CONNECT_ERROR, socket_->error_state());
 }
 
 // Test connection error - timeout
 TEST_F(CastSocketTest, TestConnectTcpTimeoutError) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnectUnresponsive();
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_TIMEOUT));
   EXPECT_CALL(*observer_, OnError(_, ChannelError::CONNECT_TIMEOUT));
   socket_->AddObserver(observer_.get());
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CONNECTING, socket_->ready_state());
   EXPECT_EQ(ChannelError::NONE, socket_->error_state());
   socket_->TriggerTimeout();
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
 }
 
 // Test connection error - TCP socket returns timeout
 TEST_F(CastSocketTest, TestConnectTcpSocketTimeoutError) {
   CreateCastSocketSecure();
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_TIMEOUT));
   EXPECT_CALL(*observer_, OnError(_, ChannelError::CONNECT_TIMEOUT));
   socket_->AddObserver(observer_.get());
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
   EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT,
             logger_->GetLastError(socket_->id()).net_return_value);
 }
 
 // Test connection error - SSL connect fails (async)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::AUTHENTICATION_ERROR));
+  EXPECT_CALL(handler_,
+              OnConnectComplete(_, ChannelError::AUTHENTICATION_ERROR));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::AUTHENTICATION_ERROR, socket_->error_state());
 }
 
 // Test connection error - SSL connect fails (sync)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_FAILED);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::AUTHENTICATION_ERROR));
+  EXPECT_CALL(handler_,
+              OnConnectComplete(_, ChannelError::AUTHENTICATION_ERROR));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::AUTHENTICATION_ERROR, socket_->error_state());
   EXPECT_EQ(net::ERR_FAILED,
             logger_->GetLastError(socket_->id()).net_return_value);
 }
 
 // Test connection error - SSL connect times out (sync)
 TEST_F(CastSocketTest, TestConnectSslConnectTimeoutSync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::ERR_CONNECTION_TIMED_OUT);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_TIMEOUT));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
   EXPECT_EQ(net::ERR_CONNECTION_TIMED_OUT,
             logger_->GetLastError(socket_->id()).net_return_value);
 }
 
 // Test connection error - SSL connect times out (async)
 TEST_F(CastSocketTest, TestConnectSslConnectTimeoutAsync) {
   CreateCastSocketSecure();
 
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::ERR_CONNECTION_TIMED_OUT);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CONNECT_TIMEOUT));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_TIMEOUT));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CONNECT_TIMEOUT, socket_->error_state());
 }
 
 // Test connection error - challenge send fails
 TEST_F(CastSocketTest, TestConnectChallengeSendError) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(CreateAuthChallenge()), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::ERR_CONNECTION_RESET));
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CAST_SOCKET_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CAST_SOCKET_ERROR));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CAST_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test connection error - connection is destroyed after the challenge is
 // sent, with the async result still lurking in the task queue.
@@ skipping 16 matching lines @@
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
 
   socket_->SetupTcpConnect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSslConnect(net::SYNCHRONOUS, net::OK);
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(CreateAuthChallenge()), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
   socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
   EXPECT_CALL(*observer_, OnError(_, ChannelError::CAST_SOCKET_ERROR));
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CAST_SOCKET_ERROR));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CAST_SOCKET_ERROR));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
   socket_->AddObserver(observer_.get());
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   socket_->GetMockTransport()->current_delegate()->OnError(
       ChannelError::CAST_SOCKET_ERROR);
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::CAST_SOCKET_ERROR, socket_->error_state());
 }
 
 TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
   CreateCastSocketSecure();
   socket_->SetupMockTransport();
   socket_->SetupTcpConnect(net::ASYNC, net::OK);
   socket_->SetupSslConnect(net::ASYNC, net::OK);
   socket_->SetVerifyChallengeResult(false);
 
   EXPECT_CALL(*observer_, OnError(_, ChannelError::AUTHENTICATION_ERROR));
   CastMessage challenge_proto = CreateAuthChallenge();
   EXPECT_CALL(*socket_->GetMockTransport(),
               SendMessage(EqualsProto(challenge_proto), _))
       .WillOnce(PostCompletionCallbackTask<1>(net::OK));
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::AUTHENTICATION_ERROR));
+  EXPECT_CALL(handler_,
+              OnConnectComplete(_, ChannelError::AUTHENTICATION_ERROR));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
   socket_->AddObserver(observer_.get());
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   socket_->GetMockTransport()->current_delegate()->OnMessage(CreateAuthReply());
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::CLOSED, socket_->ready_state());
   EXPECT_EQ(ChannelError::AUTHENTICATION_ERROR, socket_->error_state());
@@ skipping 17 matching lines @@
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
   socket_->AddReadResultForData(net::ASYNC, reply_str);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   CastMessage test_message = CreateTestMessage();
   std::string test_message_str;
   EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
   socket_->AddWriteResultForData(net::ASYNC, test_message_str);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::NONE));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::NONE));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
   EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 
   // Send the test message through a real transport object.
   EXPECT_CALL(handler_, OnWriteComplete(net::OK));
   socket_->transport()->SendMessage(
       test_message, base::Bind(&CompleteHandler::OnWriteComplete,
@@ skipping 21 matching lines @@
   std::string reply_str;
   EXPECT_TRUE(MessageFramer::Serialize(reply, &reply_str));
   socket_->AddReadResultForData(net::SYNCHRONOUS, reply_str);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   CastMessage test_message = CreateTestMessage();
   std::string test_message_str;
   EXPECT_TRUE(MessageFramer::Serialize(test_message, &test_message_str));
   socket_->AddWriteResultForData(net::SYNCHRONOUS, test_message_str);
 
-  EXPECT_CALL(handler_, OnConnectComplete(ChannelError::NONE));
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::NONE));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
   EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
   EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 
   // Send the test message through a real transport object.
   EXPECT_CALL(handler_, OnWriteComplete(net::OK));
   socket_->transport()->SendMessage(
       test_message, base::Bind(&CompleteHandler::OnWriteComplete,
@@ skipping 14 matching lines @@
   socket_->AddObserver(&observer2);
   socket_->AddObserver(&observer2);
 
   // Test notify observers
   EXPECT_CALL(observer1, OnError(_, cast_channel::ChannelError::CONNECT_ERROR));
   EXPECT_CALL(observer2, OnError(_, cast_channel::ChannelError::CONNECT_ERROR));
   CastSocketImpl::CastSocketMessageDelegate delegate(socket_.get());
   delegate.OnError(cast_channel::ChannelError::CONNECT_ERROR);
 }
 
+TEST_F(CastSocketTest, TestOpenChannelConnectingSocket) {
+  CreateCastSocketSecure();
+  socket_->SetupTcpConnectUnresponsive();
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_TIMEOUT))
+      .Times(2);
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+  socket_->TriggerTimeout();
+  RunPendingTasks();
+}
+
+TEST_F(CastSocketTest, TestOpenChannelConnectedSocket) {
+  CreateCastSocketSecure();
+  socket_->SetupTcpConnect(net::ASYNC, net::OK);
+  socket_->SetupSslConnect(net::ASYNC, net::OK);
+
+  HandleAuthHandshake();
+
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::NONE));
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+}
+
+TEST_F(CastSocketTest, TestOpenChannelClosedSocket) {
+  CreateCastSocketSecure();
+  socket_->SetupTcpConnect(net::ASYNC, net::ERR_FAILED);
+
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_ERROR));
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_CALL(handler_, OnConnectComplete(_, ChannelError::CONNECT_ERROR));
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+}
+
 }  // namespace cast_channel