[cast_channel] Make cast_channel related files not depend on "cast_channel.h"

extensions/browser/api/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 "extensions/browser/api/cast_channel/cast_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <utility>
@@ skipping 32 matching lines @@
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_info.h"
 
 // Helper for logging data with remote host IP and authentication state.
 // Assumes |ip_endpoint_| of type net::IPEndPoint and |channel_auth_| of enum
 // type ChannelAuthType are available in the current scope.
-#define CONNECTION_INFO() \
-  "[" << ip_endpoint_.ToString() << ", auth=" << channel_auth_ << "] "
+#define CONNECTION_INFO()                                                    \
+  "[" << ip_endpoint_.ToString()                                             \
+      << ", auth=" << ::cast_channel::ChannelAuthTypeToString(channel_auth_) \
+      << "] "
 #define VLOG_WITH_CONNECTION(level) VLOG(level) << CONNECTION_INFO()
 #define LOG_WITH_CONNECTION(level) LOG(level) << CONNECTION_INFO()
 
 namespace extensions {
 namespace api {
 namespace cast_channel {
 namespace {
 
 bool IsTerminalState(proto::ConnectionState state) {
   return state == proto::CONN_STATE_FINISHED ||
@@ skipping 13 matching lines @@
              std::unique_ptr<Request>*,
              const net::NetLogWithSource&) override {
     verify_result->Reset();
     verify_result->verified_cert = params.certificate();
     return net::OK;
   }
 };
 
 }  // namespace
 
+using ChannelError = ::cast_channel::ChannelError;
+using ChannelAuthType = ::cast_channel::ChannelAuthType;
+using ReadyState = ::cast_channel::ReadyState;
+
 CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
                                const net::IPEndPoint& ip_endpoint,
                                ChannelAuthType channel_auth,
                                net::NetLog* net_log,
                                const base::TimeDelta& timeout,
                                bool keep_alive,
                                const scoped_refptr<Logger>& logger,
                                uint64_t device_capabilities)
     : CastSocketImpl(owner_extension_id,
                      ip_endpoint,
@@ skipping 20 matching lines @@
       net_log_(net_log),
       keep_alive_(keep_alive),
       logger_(logger),
       auth_context_(auth_context),
       connect_timeout_(timeout),
       connect_timeout_timer_(new base::OneShotTimer),
       is_canceled_(false),
       device_capabilities_(device_capabilities),
       audio_only_(false),
       connect_state_(proto::CONN_STATE_START_CONNECT),
-      error_state_(CHANNEL_ERROR_NONE),
-      ready_state_(READY_STATE_NONE),
+      error_state_(ChannelError::NONE),
+      ready_state_(ReadyState::NONE),
       auth_delegate_(nullptr) {
   DCHECK(net_log_);
   net_log_source_.type = net::NetLogSourceType::SOCKET;
   net_log_source_.id = net_log_->NextID();
 }
 
 CastSocketImpl::~CastSocketImpl() {
   // Ensure that resources are freed but do not run pending callbacks that
   // would result in re-entrancy.
   CloseInternal();
 
   if (!connect_callback_.is_null())
-    base::ResetAndReturn(&connect_callback_).Run(CHANNEL_ERROR_UNKNOWN);
+    base::ResetAndReturn(&connect_callback_).Run(ChannelError::UNKNOWN);
 }
 
 ReadyState CastSocketImpl::ready_state() const {
   return ready_state_;
 }
 
 ChannelError CastSocketImpl::error_state() const {
   return error_state_;
 }
 
@@ skipping 89 matching lines @@
 }
 
 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) {
   DCHECK(CalledOnValidThread());
-  VLOG_WITH_CONNECTION(1) << "Connect readyState = " << ready_state_;
+  VLOG_WITH_CONNECTION(1) << "Connect readyState = "
+                          << ::cast_channel::ReadyStateToString(ready_state_);
   DCHECK_EQ(proto::CONN_STATE_START_CONNECT, connect_state_);
 
   delegate_ = std::move(delegate);
 
-  if (ready_state_ != READY_STATE_NONE) {
-    callback.Run(CHANNEL_ERROR_CONNECT_ERROR);
+  if (ready_state_ != ReadyState::NONE) {
+    callback.Run(ChannelError::CONNECT_ERROR);
     return;
   }
 
   connect_callback_ = callback;
-  SetReadyState(READY_STATE_CONNECTING);
+  SetReadyState(ReadyState::CONNECTING);
   SetConnectState(proto::CONN_STATE_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::OnConnectTimeout() {
   DCHECK(CalledOnValidThread());
   // 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(CHANNEL_ERROR_CONNECT_TIMEOUT);
+  SetErrorState(ChannelError::CONNECT_TIMEOUT);
   DoConnectCallback();
 }
 
 void CastSocketImpl::ResetConnectLoopCallback() {
   DCHECK(connect_loop_callback_.IsCancelled());
   connect_loop_callback_.Reset(
       base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
 }
 
 void CastSocketImpl::PostTaskToStartConnectLoop(int result) {
@@ skipping 43 matching lines @@
       case proto::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE:
         rv = DoAuthChallengeSendComplete(rv);
         break;
       case proto::CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE:
         rv = DoAuthChallengeReplyComplete(rv);
         DCHECK(IsTerminalState(connect_state_));
         break;
       default:
         NOTREACHED() << "Unknown state in connect flow: " << state;
         SetConnectState(proto::CONN_STATE_FINISHED);
-        SetErrorState(CHANNEL_ERROR_UNKNOWN);
+        SetErrorState(ChannelError::UNKNOWN);
         DoConnectCallback();
         return;
     }
   } while (rv != net::ERR_IO_PENDING && !IsTerminalState(connect_state_));
   // Exit the state machine if an asynchronous network operation is pending
   // or if the state machine is in the terminal "finished" state.
 
   if (IsTerminalState(connect_state_)) {
     DCHECK_NE(rv, net::ERR_IO_PENDING);
     GetTimer()->Stop();
@@ skipping 16 matching lines @@
 }
 
 int CastSocketImpl::DoTcpConnectComplete(int connect_result) {
   VLOG_WITH_CONNECTION(1) << "DoTcpConnectComplete: " << connect_result;
   logger_->LogSocketEventWithRv(channel_id_, proto::TCP_SOCKET_CONNECT_COMPLETE,
                                 connect_result);
   if (connect_result == net::OK) {
     SetConnectState(proto::CONN_STATE_SSL_CONNECT);
   } else if (connect_result == net::ERR_CONNECTION_TIMED_OUT) {
     SetConnectState(proto::CONN_STATE_FINISHED);
-    SetErrorState(CHANNEL_ERROR_CONNECT_TIMEOUT);
+    SetErrorState(ChannelError::CONNECT_TIMEOUT);
   } else {
     SetConnectState(proto::CONN_STATE_FINISHED);
-    SetErrorState(CHANNEL_ERROR_CONNECT_ERROR);
+    SetErrorState(ChannelError::CONNECT_ERROR);
   }
   return connect_result;
 }
 
 int CastSocketImpl::DoSslConnect() {
   DCHECK(connect_loop_callback_.IsCancelled());
   VLOG_WITH_CONNECTION(1) << "DoSslConnect";
   SetConnectState(proto::CONN_STATE_SSL_CONNECT_COMPLETE);
   socket_ = CreateSslSocket(std::move(tcp_socket_));
 
   int rv = socket_->Connect(
       base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
   logger_->LogSocketEventWithRv(channel_id_, proto::SSL_SOCKET_CONNECT, rv);
   return rv;
 }
 
 int CastSocketImpl::DoSslConnectComplete(int result) {
   logger_->LogSocketEventWithRv(channel_id_, proto::SSL_SOCKET_CONNECT_COMPLETE,
                                 result);
   VLOG_WITH_CONNECTION(1) << "DoSslConnectComplete: " << result;
   if (result == net::OK) {
     peer_cert_ = ExtractPeerCert();
 
     if (!peer_cert_) {
       LOG_WITH_CONNECTION(WARNING) << "Could not extract peer cert.";
       SetConnectState(proto::CONN_STATE_FINISHED);
-      SetErrorState(CHANNEL_ERROR_AUTHENTICATION_ERROR);
+      SetErrorState(ChannelError::AUTHENTICATION_ERROR);
       return net::ERR_CERT_INVALID;
     }
 
     // SSL connection succeeded.
     if (!transport_.get()) {
       // Create a channel transport if one wasn't already set (e.g. by test
       // code).
       transport_.reset(new CastTransportImpl(this->socket_.get(), channel_id_,
                                              ip_endpoint_, channel_auth_,
                                              logger_));
     }
     auth_delegate_ = new AuthTransportDelegate(this);
     transport_->SetReadDelegate(base::WrapUnique(auth_delegate_));
     SetConnectState(proto::CONN_STATE_AUTH_CHALLENGE_SEND);
   } else if (result == net::ERR_CONNECTION_TIMED_OUT) {
     SetConnectState(proto::CONN_STATE_FINISHED);
-    SetErrorState(CHANNEL_ERROR_CONNECT_TIMEOUT);
+    SetErrorState(ChannelError::CONNECT_TIMEOUT);
   } else {
     SetConnectState(proto::CONN_STATE_FINISHED);
-    SetErrorState(CHANNEL_ERROR_AUTHENTICATION_ERROR);
+    SetErrorState(ChannelError::AUTHENTICATION_ERROR);
   }
   return result;
 }
 
 int CastSocketImpl::DoAuthChallengeSend() {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSend";
   SetConnectState(proto::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE);
 
   CastMessage challenge_message;
   CreateAuthChallengeMessage(&challenge_message, auth_context_);
   VLOG_WITH_CONNECTION(1) << "Sending challenge: "
                           << CastMessageToString(challenge_message);
 
   ResetConnectLoopCallback();
   transport_->SendMessage(challenge_message, connect_loop_callback_.callback());
 
   // Always return IO_PENDING since the result is always asynchronous.
   return net::ERR_IO_PENDING;
 }
 
 int CastSocketImpl::DoAuthChallengeSendComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSendComplete: " << result;
   if (result < 0) {
     SetConnectState(proto::CONN_STATE_ERROR);
-    SetErrorState(CHANNEL_ERROR_SOCKET_ERROR);
+    SetErrorState(ChannelError::CAST_SOCKET_ERROR);
     logger_->LogSocketEventWithRv(channel_id_,
                                   proto::SEND_AUTH_CHALLENGE_FAILED, result);
     return result;
   }
   transport_->Start();
   SetConnectState(proto::CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE);
   return net::ERR_IO_PENDING;
 }
 
 CastSocketImpl::AuthTransportDelegate::AuthTransportDelegate(
     CastSocketImpl* socket)
-    : socket_(socket), error_state_(CHANNEL_ERROR_NONE) {
+    : socket_(socket), error_state_(ChannelError::NONE) {
   DCHECK(socket);
 }
 
 ChannelError CastSocketImpl::AuthTransportDelegate::error_state() const {
   return error_state_;
 }
 
 LastErrors CastSocketImpl::AuthTransportDelegate::last_errors() const {
   return last_errors_;
 }
 
 void CastSocketImpl::AuthTransportDelegate::OnError(ChannelError error_state) {
   error_state_ = error_state;
   socket_->PostTaskToStartConnectLoop(net::ERR_CONNECTION_FAILED);
 }
 
 void CastSocketImpl::AuthTransportDelegate::OnMessage(
     const CastMessage& message) {
   if (!IsAuthMessage(message)) {
-    error_state_ = CHANNEL_ERROR_TRANSPORT_ERROR;
+    error_state_ = ChannelError::TRANSPORT_ERROR;
     socket_->PostTaskToStartConnectLoop(net::ERR_INVALID_RESPONSE);
   } else {
     socket_->challenge_reply_.reset(new CastMessage(message));
     socket_->PostTaskToStartConnectLoop(net::OK);
   }
 }
 
 void CastSocketImpl::AuthTransportDelegate::Start() {
 }
 
 int CastSocketImpl::DoAuthChallengeReplyComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeReplyComplete: " << result;
 
-  if (auth_delegate_->error_state() != CHANNEL_ERROR_NONE) {
+  if (auth_delegate_->error_state() != ChannelError::NONE) {
     SetErrorState(auth_delegate_->error_state());
     SetConnectState(proto::CONN_STATE_ERROR);
     return net::ERR_CONNECTION_FAILED;
   }
   auth_delegate_ = nullptr;
 
   if (result < 0) {
     SetConnectState(proto::CONN_STATE_ERROR);
     return result;
   }
 
   if (!VerifyChallengeReply()) {
-    SetErrorState(CHANNEL_ERROR_AUTHENTICATION_ERROR);
+    SetErrorState(ChannelError::AUTHENTICATION_ERROR);
     SetConnectState(proto::CONN_STATE_ERROR);
     return net::ERR_CONNECTION_FAILED;
   }
   VLOG_WITH_CONNECTION(1) << "Auth challenge verification succeeded";
 
   SetConnectState(proto::CONN_STATE_FINISHED);
   return net::OK;
 }
 
 void CastSocketImpl::DoConnectCallback() {
-  VLOG(1) << "DoConnectCallback (error_state = " << error_state_ << ")";
+  VLOG(1) << "DoConnectCallback (error_state = "
+          << ::cast_channel::ChannelErrorToString(error_state_) << ")";
   if (connect_callback_.is_null()) {
     DLOG(FATAL) << "Connection callback invoked multiple times.";
     return;
   }
 
-  if (error_state_ == CHANNEL_ERROR_NONE) {
-    SetReadyState(READY_STATE_OPEN);
+  if (error_state_ == ChannelError::NONE) {
+    SetReadyState(ReadyState::OPEN);
     transport_->SetReadDelegate(std::move(delegate_));
   } else {
     CloseInternal();
   }
 
   base::ResetAndReturn(&connect_callback_).Run(error_state_);
 }
 
 void CastSocketImpl::Close(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   CloseInternal();
   // Run this callback last.  It may delete the socket.
   callback.Run(net::OK);
 }
 
 void CastSocketImpl::CloseInternal() {
   // TODO(mfoltz): Enforce this when CastChannelAPITest is rewritten to create
   // and free sockets on the same thread.  crbug.com/398242
   DCHECK(CalledOnValidThread());
-  if (ready_state_ == READY_STATE_CLOSED) {
+  if (ready_state_ == ReadyState::CLOSED) {
     return;
   }
 
-  VLOG_WITH_CONNECTION(1) << "Close ReadyState = " << ready_state_;
+  VLOG_WITH_CONNECTION(1) << "Close ReadyState = "
+                          << ::cast_channel::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.
   connect_loop_callback_.Cancel();
   connect_timeout_callback_.Cancel();
-  SetReadyState(READY_STATE_CLOSED);
+  SetReadyState(ReadyState::CLOSED);
 }
 
 bool CastSocketImpl::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 base::Timer* CastSocketImpl::GetTimer() {
   return connect_timeout_timer_.get();
 }
 
 void CastSocketImpl::SetConnectState(proto::ConnectionState connect_state) {
   if (connect_state_ != connect_state) {
     connect_state_ = connect_state;
   }
 }
 
 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 " << error_state;
-  DCHECK_EQ(CHANNEL_ERROR_NONE, error_state_);
+  VLOG_WITH_CONNECTION(1) << "SetErrorState "
+                          << ::cast_channel::ChannelErrorToString(error_state);
+  DCHECK_EQ(ChannelError::NONE, error_state_);
   error_state_ = error_state;
   delegate_->OnError(error_state_);
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 #undef VLOG_WITH_CONNECTION