Upstream version 9.37.197.0

[platform/framework/web/crosswalk.git] / src / chrome / browser / extensions / api / cast_channel / cast_socket_unittest.cc

diff --git a/src/chrome/browser/extensions/api/cast_channel/cast_socket_unittest.cc b/src/chrome/browser/extensions/api/cast_channel/cast_socket_unittest.cc
index d9e4aee..fb8cf41 100644 (file)
--- a/src/chrome/browser/extensions/api/cast_channel/cast_socket_unittest.cc
+++ b/src/chrome/browser/extensions/api/cast_channel/cast_socket_unittest.cc
@@ -148,7 +148,8 @@ class TestCastSocket : public CastSocket {
       ip_(ip_endpoint),
       connect_index_(0),
       extract_cert_result_(true),
-      verify_challenge_result_(true) {
+      verify_challenge_result_(true),
+      verify_challenge_disallow_(false) {
   }
 
   static net::IPEndPoint CreateIPEndPoint() {
@@ -235,6 +236,8 @@ class TestCastSocket : public CastSocket {
     verify_challenge_result_ = value;
   }
 
+  void DisallowVerifyChallengeResult() { verify_challenge_disallow_ = true; }
+
  private:
   virtual scoped_ptr<net::TCPClientSocket> CreateTcpSocket() OVERRIDE {
     net::MockConnect* connect_data = tcp_connect_data_[connect_index_].get();
@@ -264,6 +267,7 @@ class TestCastSocket : public CastSocket {
   }
 
   virtual bool VerifyChallengeReply() OVERRIDE {
+    EXPECT_FALSE(verify_challenge_disallow_);
     return verify_challenge_result_;
   }
 
@@ -282,6 +286,7 @@ class TestCastSocket : public CastSocket {
   bool extract_cert_result_;
   // Simulated result of verifying challenge reply.
   bool verify_challenge_result_;
+  bool verify_challenge_disallow_;
 };
 
 class CastSocketTest : public testing::Test {
@@ -298,7 +303,18 @@ class CastSocketTest : public testing::Test {
           test_messages_[i], &test_protos_[i]));
       ASSERT_TRUE(CastSocket::Serialize(test_protos_[i], &test_proto_strs_[i]));
     }
+  }
 
+  virtual void TearDown() OVERRIDE {
+    EXPECT_CALL(handler_, OnCloseComplete(net::OK));
+    socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
+                              base::Unretained(&handler_)));
+  }
+
+  // The caller can specify non-standard namespaces by setting "auth_namespace"
+  // (useful for negative test cases.)
+  void SetupAuthMessage(
+      const char* auth_namespace = "urn:x-cast:com.google.cast.tp.deviceauth") {
     // Create a test auth request.
     CastMessage request;
     CreateAuthChallengeMessage(&request);
@@ -306,22 +322,13 @@ class CastSocketTest : public testing::Test {
 
     // Create a test auth reply.
     MessageInfo reply;
-    CreateBinaryMessage("urn:x-cast:com.google.cast.tp.deviceauth",
-                        "sender-0",
-                        "receiver-0",
-                        "abcd",
-                        &reply);
+    CreateBinaryMessage(
+        auth_namespace, "sender-0", "receiver-0", "abcd", &reply);
     CastMessage reply_msg;
     ASSERT_TRUE(MessageInfoToCastMessage(reply, &reply_msg));
     ASSERT_TRUE(CastSocket::Serialize(reply_msg, &auth_reply_));
   }
 
-  virtual void TearDown() OVERRIDE {
-    EXPECT_CALL(handler_, OnCloseComplete(net::OK));
-    socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
-                              base::Unretained(&handler_)));
-  }
-
   void CreateCastSocket() {
     socket_ = TestCastSocket::Create(&mock_delegate_);
   }
@@ -366,6 +373,7 @@ class CastSocketTest : public testing::Test {
 TEST_F(CastSocketTest, TestConnectAndClose) {
   CreateCastSocket();
   ConnectHelper();
+  SetupAuthMessage();
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 
@@ -381,6 +389,7 @@ TEST_F(CastSocketTest, TestConnectAndClose) {
 // - SSL connection succeeds (async)
 TEST_F(CastSocketTest, TestConnect) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::OK);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
@@ -402,6 +411,7 @@ TEST_F(CastSocketTest, TestConnect) {
 // - Second SSL connection succeeds (async)
 TEST_F(CastSocketTest, TestConnectTwoStep) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
   socket_->SetupTcp2Connect(net::ASYNC, net::OK);
@@ -426,6 +436,7 @@ TEST_F(CastSocketTest, TestConnectTwoStep) {
 // - The flow should NOT be tried again
 TEST_F(CastSocketTest, TestConnectMaxTwoAttempts) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
   socket_->SetupTcp2Connect(net::ASYNC, net::OK);
@@ -451,6 +462,7 @@ TEST_F(CastSocketTest, TestConnectMaxTwoAttempts) {
 // - Credentials are verified successfuly
 TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
@@ -472,6 +484,7 @@ TEST_F(CastSocketTest, TestConnectFullSecureFlowAsync) {
 // Same as TestFullSecureConnectionFlowAsync, but operations are synchronous.
 TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID);
@@ -490,9 +503,35 @@ TEST_F(CastSocketTest, TestConnectFullSecureFlowSync) {
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
+// Test that an AuthMessage with a mangled namespace triggers cancelation
+// of the connection event loop.
+TEST_F(CastSocketTest, TestConnectAuthMessageCorrupted) {
+  CreateCastSocketSecure();
+  SetupAuthMessage("bogus_namespace");
+
+  socket_->SetupTcp1Connect(net::ASYNC, net::OK);
+  socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
+  socket_->SetupTcp2Connect(net::ASYNC, net::OK);
+  socket_->SetupSsl2Connect(net::ASYNC, net::OK);
+  socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
+  socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
+  socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
+  // Guard against VerifyChallengeResult() being triggered.
+  socket_->DisallowVerifyChallengeResult();
+
+  EXPECT_CALL(handler_, OnConnectComplete(net::ERR_FAILED));
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
+                              base::Unretained(&handler_)));
+  RunPendingTasks();
+
+  EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
+  EXPECT_EQ(cast_channel::CHANNEL_ERROR_CONNECT_ERROR, socket_->error_state());
+}
+
 // Test connection error - TCP connect fails (async)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::ASYNC, net::ERR_FAILED);
 
@@ -508,6 +547,7 @@ TEST_F(CastSocketTest, TestConnectTcpConnectErrorAsync) {
 // Test connection error - TCP connect fails (sync)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
 
@@ -523,6 +563,7 @@ TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
 // Test connection error - SSL connect fails (async)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
@@ -539,6 +580,7 @@ TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
 // Test connection error - SSL connect fails (async)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_FAILED);
@@ -555,6 +597,7 @@ TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
 // Test connection error - cert extraction error (async)
 TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->SetupTcp1Connect(net::ASYNC, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
   // Set cert extraction to fail
@@ -572,6 +615,7 @@ TEST_F(CastSocketTest, TestConnectCertExtractionErrorAsync) {
 // Test connection error - cert extraction error (sync)
 TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_CERT_AUTHORITY_INVALID);
   // Set cert extraction to fail
@@ -589,6 +633,7 @@ TEST_F(CastSocketTest, TestConnectCertExtractionErrorSync) {
 // Test connection error - challenge send fails
 TEST_F(CastSocketTest, TestConnectChallengeSendError) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
@@ -606,6 +651,7 @@ TEST_F(CastSocketTest, TestConnectChallengeSendError) {
 // Test connection error - challenge reply receive fails
 TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
@@ -624,6 +670,7 @@ TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
 // Test connection error - challenge reply verification fails
 TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
@@ -646,6 +693,7 @@ TEST_F(CastSocketTest, TestWriteAsync) {
   CreateCastSocket();
   socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0]);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
@@ -662,6 +710,7 @@ TEST_F(CastSocketTest, TestWriteSync) {
   CreateCastSocket();
   socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
@@ -678,6 +727,7 @@ TEST_F(CastSocketTest, TestWriteChunkedAsync) {
   CreateCastSocket();
   socket_->AddWriteResultForMessage(net::ASYNC, test_proto_strs_[0], 2);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
@@ -694,6 +744,7 @@ TEST_F(CastSocketTest, TestWriteChunkedSync) {
   CreateCastSocket();
   socket_->AddWriteResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(test_proto_strs_[0].size()));
   socket_->SendMessage(test_messages_[0],
@@ -714,6 +765,7 @@ TEST_F(CastSocketTest, TestWriteManyAsync) {
     EXPECT_CALL(handler_, OnWriteComplete(msg_size));
   }
   ConnectHelper();
+  SetupAuthMessage();
 
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     socket_->SendMessage(test_messages_[i],
@@ -735,6 +787,7 @@ TEST_F(CastSocketTest, TestWriteManySync) {
     EXPECT_CALL(handler_, OnWriteComplete(msg_size));
   }
   ConnectHelper();
+  SetupAuthMessage();
 
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     socket_->SendMessage(test_messages_[i],
@@ -750,6 +803,7 @@ TEST_F(CastSocketTest, TestWriteManySync) {
 // Test write error - not connected
 TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
   CreateCastSocket();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   socket_->SendMessage(test_messages_[0],
@@ -764,6 +818,7 @@ TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
 TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
   CreateCastSocket();
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   size_t size = CastSocket::MessageHeader::max_message_size() + 1;
@@ -783,6 +838,7 @@ TEST_F(CastSocketTest, TestWriteNetworkErrorSync) {
   CreateCastSocket();
   socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
@@ -801,6 +857,7 @@ TEST_F(CastSocketTest, TestWriteErrorAsync) {
   CreateCastSocket();
   socket_->AddWriteResult(net::ASYNC, net::ERR_FAILED);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
@@ -819,6 +876,7 @@ TEST_F(CastSocketTest, TestWriteErrorZeroBytesWritten) {
   CreateCastSocket();
   socket_->AddWriteResult(net::SYNCHRONOUS, 0);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
@@ -838,6 +896,7 @@ TEST_F(CastSocketTest, TestWriteErrorWithMultiplePendingWritesAsync) {
   CreateCastSocket();
   socket_->AddWriteResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED);
   ConnectHelper();
+  SetupAuthMessage();
 
   const int num_writes = arraysize(test_messages_);
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_SOCKET_NOT_CONNECTED))
@@ -862,6 +921,7 @@ TEST_F(CastSocketTest, TestReadAsync) {
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
@@ -870,6 +930,7 @@ TEST_F(CastSocketTest, TestReadAsync) {
 // Test read success - single message (sync)
 TEST_F(CastSocketTest, TestReadSync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0]);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
@@ -882,6 +943,7 @@ TEST_F(CastSocketTest, TestReadSync) {
 // Test read success - single message received in multiple chunks (async)
 TEST_F(CastSocketTest, TestReadChunkedAsync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0], 2);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
@@ -894,6 +956,7 @@ TEST_F(CastSocketTest, TestReadChunkedAsync) {
 // Test read success - single message received in multiple chunks (sync)
 TEST_F(CastSocketTest, TestReadChunkedSync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[0], 2);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()));
@@ -906,6 +969,7 @@ TEST_F(CastSocketTest, TestReadChunkedSync) {
 // Test read success - multiple messages (async)
 TEST_F(CastSocketTest, TestReadManyAsync) {
   CreateCastSocket();
+  SetupAuthMessage();
   size_t num_reads = arraysize(test_proto_strs_);
   for (size_t i = 0; i < num_reads; i++)
     socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[i]);
@@ -921,6 +985,7 @@ TEST_F(CastSocketTest, TestReadManyAsync) {
 // Test read success - multiple messages (sync)
 TEST_F(CastSocketTest, TestReadManySync) {
   CreateCastSocket();
+  SetupAuthMessage();
   size_t num_reads = arraysize(test_proto_strs_);
   for (size_t i = 0; i < num_reads; i++)
     socket_->AddReadResultForMessage(net::SYNCHRONOUS, test_proto_strs_[i]);
@@ -936,6 +1001,7 @@ TEST_F(CastSocketTest, TestReadManySync) {
 // Test read error - network error (async)
 TEST_F(CastSocketTest, TestReadErrorAsync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->AddReadResult(net::ASYNC, net::ERR_SOCKET_NOT_CONNECTED);
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
@@ -949,6 +1015,7 @@ TEST_F(CastSocketTest, TestReadErrorAsync) {
 // Test read error - network error (sync)
 TEST_F(CastSocketTest, TestReadErrorSync) {
   CreateCastSocket();
+  SetupAuthMessage();
   socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_SOCKET_NOT_CONNECTED);
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
@@ -962,6 +1029,7 @@ TEST_F(CastSocketTest, TestReadErrorSync) {
 // Test read error - header parse error
 TEST_F(CastSocketTest, TestReadHeaderParseError) {
   CreateCastSocket();
+  SetupAuthMessage();
   uint32 body_size = base::HostToNet32(
       CastSocket::MessageHeader::max_message_size() + 1);
   // TODO(munjal): Add a method to cast_message_util.h to serialize messages
@@ -981,6 +1049,7 @@ TEST_F(CastSocketTest, TestReadHeaderParseError) {
 // Test read error - body parse error
 TEST_F(CastSocketTest, TestReadBodyParseError) {
   CreateCastSocket();
+  SetupAuthMessage();
   char body[] = "some body";
   uint32 body_size = base::HostToNet32(arraysize(body));
   char header[sizeof(body_size)];