[cast_channel] Make CastMessageHandler a CastSocket::Observer instead of CastTransport::Delegate

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 313 matching lines @@
   // If true, makes TCP connection process stall. For timeout testing.
   bool tcp_unresponsive_;
   std::unique_ptr<base::MockTimer> mock_timer_;
   MockCastTransport* mock_transport_;
 
   DISALLOW_COPY_AND_ASSIGN(TestCastSocket);
 };
 
 class CastSocketTest : public testing::Test {
  public:
-  CastSocketTest() : logger_(new Logger()), delegate_(new MockDelegate) {}
+  CastSocketTest()
+      : logger_(new Logger()), observer_(new MockCastSocketObserver()) {}
   ~CastSocketTest() override {}
 
-  void SetUp() override { EXPECT_CALL(*delegate_, OnMessage(_)).Times(0); }
+  void SetUp() override { EXPECT_CALL(*observer_, OnMessage(_, _)).Times(0); }
 
   void TearDown() override {
     if (socket_.get()) {
       EXPECT_CALL(handler_, OnCloseComplete(net::OK));
       socket_->Close(base::Bind(&CompleteHandler::OnCloseComplete,
                                 base::Unretained(&handler_)));
     }
   }
 
   void CreateCastSocketSecure() {
     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));
-    socket_->Connect(std::move(delegate_),
-                     base::Bind(&CompleteHandler::OnConnectComplete,
+    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.
   void RunPendingTasks() {
     base::RunLoop run_loop;
     run_loop.RunUntilIdle();
   }
 
   base::MessageLoop message_loop_;
   Logger* logger_;
   std::unique_ptr<TestCastSocket> socket_;
   CompleteHandler handler_;
-  std::unique_ptr<MockDelegate> delegate_;
+  std::unique_ptr<MockCastSocketObserver> observer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CastSocketTest);
 };
 
 // Tests that the following connection flow works:
 // - TCP connection succeeds (async)
 // - SSL connection succeeds (async)
 // - Cert is extracted successfully
 // - Challenge request is sent (async)
@@ skipping 36 matching lines @@
 
   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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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(*delegate_, OnError(ChannelError::CONNECT_TIMEOUT));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  EXPECT_CALL(*observer_, OnError(_, ChannelError::CONNECT_TIMEOUT));
+  socket_->AddObserver("id", std::move(observer_));
+  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(*delegate_, OnError(ChannelError::CONNECT_TIMEOUT));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  EXPECT_CALL(*observer_, OnError(_, ChannelError::CONNECT_TIMEOUT));
+  socket_->AddObserver("id", std::move(observer_));
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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.
 TEST_F(CastSocketTest, TestConnectDestroyedAfterChallengeSent) {
   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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  socket_->Connect(base::Bind(&CompleteHandler::OnConnectComplete,
                               base::Unretained(&handler_)));
   socket_.reset();
   RunPendingTasks();
 }
 
 // Test connection error - challenge reply receive fails
 TEST_F(CastSocketTest, TestConnectChallengeReplyReceiveError) {
   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(*delegate_, OnError(ChannelError::CAST_SOCKET_ERROR));
+  EXPECT_CALL(*observer_, OnError(_, ChannelError::CAST_SOCKET_ERROR));
   EXPECT_CALL(handler_, OnConnectComplete(ChannelError::CAST_SOCKET_ERROR));
   EXPECT_CALL(*socket_->GetMockTransport(), Start());
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  socket_->AddObserver("id", std::move(observer_));
+  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(*delegate_, OnError(ChannelError::AUTHENTICATION_ERROR));
+  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(*socket_->GetMockTransport(), Start());
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  socket_->AddObserver("id", std::move(observer_));
+  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());
 }
 
 // Sends message data through an actual non-mocked CastTransport object,
@@ skipping 15 matching lines @@
   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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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,
                                base::Unretained(&handler_)));
@@ skipping 21 matching lines @@
   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));
-  socket_->Connect(std::move(delegate_),
-                   base::Bind(&CompleteHandler::OnConnectComplete,
+  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,
                                base::Unretained(&handler_)));
   RunPendingTasks();
 
   EXPECT_EQ(ReadyState::OPEN, socket_->ready_state());
   EXPECT_EQ(ChannelError::NONE, socket_->error_state());
 }
 
+TEST_F(CastSocketTest, TestObservers) {
+  CreateCastSocketSecure();
+  std::string id1 = "id1";
+  std::string id2 = "id2";
+  EXPECT_FALSE(socket_->HasObserver(id1));
+  EXPECT_FALSE(socket_->HasObserver(id2));
+
+  // Test AddObserever
+  MockCastSocketObserver* observer1 = new MockCastSocketObserver();
+  MockCastSocketObserver* observer2 = new MockCastSocketObserver();
+  socket_->AddObserver(id1, base::WrapUnique(observer1));
+  EXPECT_TRUE(socket_->HasObserver(id1));
+  socket_->AddObserver(id2, base::WrapUnique(observer2));
+  EXPECT_TRUE(socket_->HasObserver(id2));
+
+  // 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);
+}
+
 }  // namespace cast_channel