Fix error handling for message parse errors that occur during connection setup.

chrome/browser/extensions/api/cast_channel/cast_socket_unittest.cc

 // Copyright 2013 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/extensions/api/cast_channel/cast_socket.h"
 
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/sys_byteorder.h"
@@ skipping 130 matching lines @@
   }
 
   explicit TestCastSocket(MockCastSocketDelegate* delegate,
                           const net::IPEndPoint& ip_endpoint,
                           ChannelAuthType channel_auth) :
         CastSocket("abcdefg", ip_endpoint, channel_auth, delegate,
                    &capturing_net_log_),
       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() {
     net::IPAddressNumber number;
     number.push_back(192);
     number.push_back(0);
     number.push_back(0);
     number.push_back(1);
     return net::IPEndPoint(number, 8009);
   }
@@ skipping 66 matching lines @@
     }
   }
 
   void SetExtractCertResult(bool value) {
     extract_cert_result_ = value;
   }
   void SetVerifyChallengeResult(bool value) {
     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();
     connect_data->peer_addr = ip_;
     return scoped_ptr<net::TCPClientSocket>(new MockTCPSocket(*connect_data));
   }
 
   virtual scoped_ptr<net::SSLClientSocket> CreateSslSocket(
       scoped_ptr<net::StreamSocket> socket) OVERRIDE {
     net::MockConnect* connect_data = ssl_connect_data_[connect_index_].get();
     connect_data->peer_addr = ip_;
     ++connect_index_;
 
     ssl_data_.reset(new net::StaticSocketDataProvider(
         reads_.data(), reads_.size(), writes_.data(), writes_.size()));
     ssl_data_->set_connect_data(*connect_data);
     // NOTE: net::MockTCPClientSocket inherits from net::SSLClientSocket !!
     return scoped_ptr<net::SSLClientSocket>(
         new net::MockTCPClientSocket(
             net::AddressList(), &capturing_net_log_, ssl_data_.get()));
   }
 
   virtual bool ExtractPeerCert(std::string* cert) OVERRIDE {
     if (extract_cert_result_)
       cert->assign("dummy_test_cert");
     return extract_cert_result_;
   }
 
   virtual bool VerifyChallengeReply() OVERRIDE {
+    EXPECT_EQ(false, verify_challenge_disallow_);
     return verify_challenge_result_;
   }
 
   net::CapturingNetLog capturing_net_log_;
   net::IPEndPoint ip_;
   // Simulated connect data
   scoped_ptr<net::MockConnect> tcp_connect_data_[2];
   scoped_ptr<net::MockConnect> ssl_connect_data_[2];
   // Simulated read / write data
   std::vector<net::MockWrite> writes_;
   std::vector<net::MockRead> reads_;
   scoped_ptr<net::SocketDataProvider> ssl_data_;
   // Number of times Connect method is called
   size_t connect_index_;
   // Simulated result of peer cert extraction.
   bool extract_cert_result_;
   // Simulated result of verifying challenge reply.
   bool verify_challenge_result_;
+  bool verify_challenge_disallow_;
 };
 
 class CastSocketTest : public testing::Test {
  public:
   CastSocketTest() {}
   virtual ~CastSocketTest() {}
 
   virtual void SetUp() OVERRIDE {
     // Create a few test messages
     for (size_t i = 0; i < arraysize(test_messages_); i++) {
       CreateStringMessage("urn:cast", "1", "2", kTestData[i],
                           &test_messages_[i]);
       ASSERT_TRUE(MessageInfoToCastMessage(
           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);
     ASSERT_TRUE(CastSocket::Serialize(request, &auth_request_));
 
     // Create a test auth reply.
     MessageInfo reply;
-    CreateBinaryMessage("urn:x-cast:com.google.cast.tp.deviceauth",
+    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_);
   }
 
   void CreateCastSocketSecure() {
     socket_ = TestCastSocket::CreateSecure(&mock_delegate_);
   }
 
   // Sets up CastSocket::Connect to succeed.
   // Connecting the socket also starts the read loop; so we add a mock
@@ skipping 24 matching lines @@
   CastMessage test_protos_[arraysize(kTestData)];
   std::string test_proto_strs_[arraysize(kTestData)];
   std::string auth_request_;
   std::string auth_reply_;
 };
 
 // Tests connecting and closing the socket.
 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());
 
   EXPECT_CALL(handler_, OnCloseComplete(net::OK));
   socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
                             base::Unretained(&handler_)));
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (async)
 // - 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);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection fails with cert error (async)
 // - Cert is extracted successfully
 // - Second TCP connection succeeds (async)
 // - 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);
   socket_->SetupSsl2Connect(net::ASYNC, net::OK);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection fails with cert error (async)
 // - Cert is extracted successfully
 // - Second TCP connection succeeds (async)
 // - Second SSL connection fails (async)
 // - 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);
   socket_->SetupSsl2Connect(net::ASYNC, net::ERR_CERT_AUTHORITY_INVALID);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
   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());
 }
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection fails with cert error (async)
 // - Cert is extracted successfully
 // - Second TCP connection succeeds (async)
 // - Second SSL connection succeeds (async)
 // - Challenge request is sent (async)
 // - Challenge response is received (async)
 // - 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);
   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);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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);
   socket_->SetupTcp2Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl2Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResultForMessage(net::SYNCHRONOUS, auth_request_);
   socket_->AddReadResultForMessage(net::SYNCHRONOUS, auth_reply_);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::OK));
   socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   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);
 
   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 (sync)
 TEST_F(CastSocketTest, TestConnectTcpConnectErrorSync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
 
   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 - SSL connect fails (async)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorAsync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::ERR_FAILED);
 
   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 - SSL connect fails (async)
 TEST_F(CastSocketTest, TestConnectSslConnectErrorSync) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::ASYNC, net::ERR_FAILED);
 
   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 - 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
   socket_->SetExtractCertResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
   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 - 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
   socket_->SetExtractCertResult(false);
 
   EXPECT_CALL(handler_, OnConnectComplete(net::ERR_CERT_AUTHORITY_INVALID));
   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 - challenge send fails
 TEST_F(CastSocketTest, TestConnectChallengeSendError) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResult(net::SYNCHRONOUS, net::ERR_FAILED);
 
   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 - challenge reply receive fails
 TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
   socket_->AddReadResult(net::SYNCHRONOUS, net::ERR_FAILED);
 
   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 - challenge reply verification fails
 TEST_F(CastSocketTest, TestConnectChallengeVerificationFails) {
   CreateCastSocketSecure();
+  SetupAuthMessage();
 
   socket_->SetupTcp1Connect(net::SYNCHRONOUS, net::OK);
   socket_->SetupSsl1Connect(net::SYNCHRONOUS, net::OK);
   socket_->AddWriteResultForMessage(net::ASYNC, auth_request_);
   socket_->AddReadResultForMessage(net::ASYNC, auth_reply_);
   socket_->AddReadResult(net::ASYNC, net::ERR_IO_PENDING);
   socket_->SetVerifyChallengeResult(false);
 
   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 write success - single message (async)
 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],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write success - single message (sync)
 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],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write success - single message sent in multiple chunks (async)
 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],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write success - single message sent in multiple chunks (sync)
 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],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write success - multiple messages (async)
 TEST_F(CastSocketTest, TestWriteManyAsync) {
   CreateCastSocket();
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     size_t msg_size = test_proto_strs_[i].size();
     socket_->AddWriteResult(net::ASYNC, msg_size);
     EXPECT_CALL(handler_, OnWriteComplete(msg_size));
   }
   ConnectHelper();
+  SetupAuthMessage();
 
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     socket_->SendMessage(test_messages_[i],
                          base::Bind(&CompleteHandler::OnWriteComplete,
                                     base::Unretained(&handler_)));
   }
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write success - multiple messages (sync)
 TEST_F(CastSocketTest, TestWriteManySync) {
   CreateCastSocket();
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     size_t msg_size = test_proto_strs_[i].size();
     socket_->AddWriteResult(net::SYNCHRONOUS, msg_size);
     EXPECT_CALL(handler_, OnWriteComplete(msg_size));
   }
   ConnectHelper();
+  SetupAuthMessage();
 
   for (size_t i = 0; i < arraysize(test_messages_); i++) {
     socket_->SendMessage(test_messages_[i],
                          base::Bind(&CompleteHandler::OnWriteComplete,
                                     base::Unretained(&handler_)));
   }
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write error - not connected
 TEST_F(CastSocketTest, TestWriteErrorNotConnected) {
   CreateCastSocket();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
 
   EXPECT_EQ(cast_channel::READY_STATE_NONE, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // Test write error - very large message
 TEST_F(CastSocketTest, TestWriteErrorLargeMessage) {
   CreateCastSocket();
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   size_t size = CastSocket::MessageHeader::max_message_size() + 1;
   test_messages_[0].data.reset(
       new base::StringValue(std::string(size, 'a')));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 
 }
 
 // Test write error - network error (sync)
 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_,
               OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test write error - network error (async)
 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_,
               OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test write error - 0 bytes written should be considered an error
 TEST_F(CastSocketTest, TestWriteErrorZeroBytesWritten) {
   CreateCastSocket();
   socket_->AddWriteResult(net::SYNCHRONOUS, 0);
   ConnectHelper();
+  SetupAuthMessage();
 
   EXPECT_CALL(handler_, OnWriteComplete(net::ERR_FAILED));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
   socket_->SendMessage(test_messages_[0],
                        base::Bind(&CompleteHandler::OnWriteComplete,
                                   base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test that when an error occurrs in one write, write callback is invoked for
 // all pending writes with the error
 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))
       .Times(num_writes);
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(), cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
   for (int i = 0; i < num_writes; i++) {
     socket_->SendMessage(test_messages_[i],
                          base::Bind(&CompleteHandler::OnWriteComplete,
                                     base::Unretained(&handler_)));
   }
   RunPendingTasks();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // Test read success - single message (async)
 TEST_F(CastSocketTest, TestReadAsync) {
   CreateCastSocket();
   socket_->AddReadResultForMessage(net::ASYNC, test_proto_strs_[0]);
   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());
 }
 
 // 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&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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&>()));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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]);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()))
       .Times(num_reads);
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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]);
   EXPECT_CALL(mock_delegate_,
               OnMessage(socket_.get(), A<const MessageInfo&>()))
       .Times(num_reads);
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_OPEN, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_NONE, socket_->error_state());
 }
 
 // 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(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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(),
                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_SOCKET_ERROR, socket_->error_state());
 }
 
 // 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
   char header[sizeof(body_size)];
   memcpy(&header, &body_size, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
             socket_->error_state());
 }
 
 // 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)];
   memcpy(&header, &body_size, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, header, arraysize(header));
   socket_->AddReadResult(net::SYNCHRONOUS, body, arraysize(body));
   EXPECT_CALL(mock_delegate_,
               OnError(socket_.get(),
                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE));
   ConnectHelper();
 
   EXPECT_EQ(cast_channel::READY_STATE_CLOSED, socket_->ready_state());
   EXPECT_EQ(cast_channel::CHANNEL_ERROR_INVALID_MESSAGE,
             socket_->error_state());
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions