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

components/cast_channel/cast_socket.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 <stdlib.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 222 matching lines @@
     }
   }
   return result.success();
 }
 
 void CastSocketImpl::SetTransportForTesting(
     std::unique_ptr<CastTransport> transport) {
   transport_ = std::move(transport);
 }
 
-void CastSocketImpl::Connect(std::unique_ptr<CastTransport::Delegate> delegate,
-                             base::Callback<void(ChannelError)> callback) {
+void CastSocketImpl::Connect(base::Callback<void(ChannelError)> callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   VLOG_WITH_CONNECTION(1) << "Connect readyState = "
-                          << ::cast_channel::ReadyStateToString(ready_state_);
+                          << ReadyStateToString(ready_state_);
   DCHECK_EQ(ConnectionState::START_CONNECT, connect_state_);
 
-  delegate_ = std::move(delegate);
+  delegate_ = base::MakeUnique<CastSocketMessageDelegate>(this);
 
   if (ready_state_ != ReadyState::NONE) {
     callback.Run(ChannelError::CONNECT_ERROR);
     return;
   }
 
   connect_callback_ = callback;
   SetReadyState(ReadyState::CONNECTING);
   SetConnectState(ConnectionState::TCP_CONNECT);
 
   // Set up connection timeout.
   if (connect_timeout_.InMicroseconds() > 0) {
     DCHECK(connect_timeout_callback_.IsCancelled());
     connect_timeout_callback_.Reset(
         base::Bind(&CastSocketImpl::OnConnectTimeout, base::Unretained(this)));
     GetTimer()->Start(FROM_HERE, connect_timeout_,
                       connect_timeout_callback_.callback());
   }
 
   DoConnectLoop(net::OK);
 }
 
 CastTransport* CastSocketImpl::transport() const {
   return transport_.get();
 }
 
+void CastSocketImpl::AddObserver(Observer* observer) {
+  DCHECK(observer);
+  if (!observers_.HasObserver(observer))
+    observers_.AddObserver(observer);
+}
+
 void CastSocketImpl::OnConnectTimeout() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   // Stop all pending connection setup tasks and report back to the client.
   is_canceled_ = true;
   VLOG_WITH_CONNECTION(1) << "Timeout while establishing a connection.";
   SetErrorState(ChannelError::CONNECT_TIMEOUT);
   DoConnectCallback();
 }
 
 void CastSocketImpl::ResetConnectLoopCallback() {
@@ skipping 232 matching lines @@
     return net::ERR_CONNECTION_FAILED;
   }
   VLOG_WITH_CONNECTION(1) << "Auth challenge verification succeeded";
 
   SetConnectState(ConnectionState::FINISHED);
   return net::OK;
 }
 
 void CastSocketImpl::DoConnectCallback() {
   VLOG(1) << "DoConnectCallback (error_state = "
-          << ::cast_channel::ChannelErrorToString(error_state_) << ")";
+          << ChannelErrorToString(error_state_) << ")";
   if (connect_callback_.is_null()) {
     DLOG(FATAL) << "Connection callback invoked multiple times.";
     return;
   }
 
   if (error_state_ == ChannelError::NONE) {
     SetReadyState(ReadyState::OPEN);
     if (keep_alive()) {
       auto* keep_alive_delegate =
           new KeepAliveDelegate(this, logger_, std::move(delegate_),
@@ skipping 17 matching lines @@
 
 void CastSocketImpl::CloseInternal() {
   // TODO(mfoltz): Enforce this when CastChannelAPITest is rewritten to create
   // and free sockets on the same thread.  crbug.com/398242
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (ready_state_ == ReadyState::CLOSED) {
     return;
   }
 
   VLOG_WITH_CONNECTION(1) << "Close ReadyState = "
-                          << ::cast_channel::ReadyStateToString(ready_state_);
+                          << ReadyStateToString(ready_state_);
   transport_.reset();
   tcp_socket_.reset();
   socket_.reset();
   transport_security_state_.reset();
   if (GetTimer()) {
     GetTimer()->Stop();
   }
 
   // Cancel callbacks that we queued ourselves to re-enter the connect or read
   // loops.
@@ skipping 12 matching lines @@
   }
 }
 
 void CastSocketImpl::SetReadyState(ReadyState ready_state) {
   if (ready_state_ != ready_state)
     ready_state_ = ready_state;
 }
 
 void CastSocketImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(1) << "SetErrorState "
-                          << ::cast_channel::ChannelErrorToString(error_state);
+                          << ChannelErrorToString(error_state);
   DCHECK_EQ(ChannelError::NONE, error_state_);
   error_state_ = error_state;
   delegate_->OnError(error_state_);
 }
 
+CastSocketImpl::CastSocketMessageDelegate::CastSocketMessageDelegate(
+    CastSocketImpl* socket)
+    : socket_(socket) {
+  DCHECK(socket_);
+}
+
+CastSocketImpl::CastSocketMessageDelegate::~CastSocketMessageDelegate() {}
+
+// CastTransport::Delegate implementation.
+void CastSocketImpl::CastSocketMessageDelegate::OnError(
+    ChannelError error_state) {
+  for (auto& observer : socket_->observers_)
+    observer.OnError(*socket_, error_state);
+}
+
+void CastSocketImpl::CastSocketMessageDelegate::OnMessage(
+    const CastMessage& message) {
+  for (auto& observer : socket_->observers_)
+    observer.OnMessage(*socket_, message);
+}
+
+void CastSocketImpl::CastSocketMessageDelegate::Start() {}
+
 }  // namespace cast_channel
 #undef VLOG_WITH_CONNECTION